@capacitor-community/admob 8.2.0 → 8.2.1

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

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

@@ -0,0 +1,187 @@
+import Foundation
+import GoogleMobileAds
+import UIKit
+
+final class PluginNativeAdView: NativeAdView {
+    private let isSmall: Bool
+    private let attributionLabel = UILabel()
+    private let headlineLabel = UILabel()
+    private let bodyLabel = UILabel()
+    private let advertiserLabel = UILabel()
+    private let iconImageView = UIImageView()
+    private let actionButton = UIButton(type: .system)
+    private let nativeMediaView = MediaView()
+
+    init(nativeAd: NativeAd, template: String, style: [String: Any]) {
+        self.isSmall = template == "small"
+        super.init(frame: .zero)
+        clipsToBounds = true
+        configure(nativeAd: nativeAd, style: style)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        let padding: CGFloat = 12
+        let available = bounds.insetBy(dx: padding, dy: padding)
+
+        attributionLabel.frame = CGRect(x: padding, y: padding, width: 28, height: 20)
+
+        if isSmall {
+            layoutDetails(
+                in: CGRect(
+                    x: available.minX,
+                    y: attributionLabel.frame.maxY + 4,
+                    width: available.width,
+                    height: max(0, available.maxY - attributionLabel.frame.maxY - 4)
+                )
+            )
+        } else {
+            let mediaHeight = max(120, available.height * 0.58)
+            nativeMediaView.frame = CGRect(
+                x: available.minX,
+                y: available.minY,
+                width: available.width,
+                height: min(mediaHeight, available.height)
+            )
+            layoutDetails(
+                in: CGRect(
+                    x: available.minX,
+                    y: nativeMediaView.frame.maxY + 8,
+                    width: available.width,
+                    height: max(0, available.maxY - nativeMediaView.frame.maxY - 8)
+                )
+            )
+        }
+        bringSubviewToFront(attributionLabel)
+    }
+
+    private func layoutDetails(in rect: CGRect) {
+        let headlineHeight = min(42, max(22, rect.height * 0.27))
+        headlineLabel.frame = CGRect(x: rect.minX, y: rect.minY, width: rect.width, height: headlineHeight)
+        let bodyHeight = bodyLabel.isHidden ? 0 : min(38, max(18, rect.height * 0.22))
+        bodyLabel.frame = CGRect(x: rect.minX, y: headlineLabel.frame.maxY, width: rect.width, height: bodyHeight)
+
+        let footerY = bodyLabel.frame.maxY + 4
+        let footerHeight = max(0, rect.maxY - footerY)
+        let iconSize = min(32, footerHeight)
+        iconImageView.frame = CGRect(x: rect.minX, y: footerY, width: iconSize, height: iconSize)
+        let actionWidth = actionButton.isHidden ? 0 : min(128, rect.width * 0.4)
+        actionButton.frame = CGRect(x: rect.maxX - actionWidth, y: footerY, width: actionWidth, height: min(40, footerHeight))
+        advertiserLabel.frame = CGRect(
+            x: iconImageView.isHidden ? rect.minX : iconImageView.frame.maxX + 6,
+            y: footerY,
+            width: max(0, actionButton.frame.minX - (iconImageView.isHidden ? rect.minX : iconImageView.frame.maxX + 6) - 6),
+            height: min(32, footerHeight)
+        )
+    }
+
+    private func configure(nativeAd: NativeAd, style: [String: Any]) {
+        backgroundColor = color(style["backgroundColor"] as? String) ?? .white
+        layer.cornerRadius = number(style["cornerRadius"], fallback: 0)
+        layer.borderWidth = number(style["borderWidth"], fallback: 0)
+        layer.borderColor = (color(style["borderColor"] as? String) ?? .clear).cgColor
+
+        configureAttribution()
+
+        headlineLabel.text = nativeAd.headline
+        headlineLabel.numberOfLines = 2
+        headlineLabel.font = .boldSystemFont(
+            ofSize: fontSize(style["headlineFontSize"], fallback: 16, range: 12 ... 24)
+        )
+        headlineLabel.textColor = color(style["headlineColor"] as? String) ?? .black
+        addSubview(headlineLabel)
+        headlineView = headlineLabel
+
+        bodyLabel.text = nativeAd.body
+        bodyLabel.numberOfLines = isSmall ? 1 : 2
+        bodyLabel.font = .systemFont(ofSize: fontSize(style["bodyFontSize"], fallback: 13, range: 10 ... 18))
+        bodyLabel.textColor = color(style["bodyColor"] as? String) ?? .darkGray
+        bodyLabel.isHidden = isSmall || nativeAd.body == nil
+        addSubview(bodyLabel)
+        bodyView = bodyLabel
+
+        advertiserLabel.text = nativeAd.advertiser
+        advertiserLabel.font = .systemFont(ofSize: 11)
+        advertiserLabel.numberOfLines = 1
+        advertiserLabel.isHidden = nativeAd.advertiser == nil
+        addSubview(advertiserLabel)
+        advertiserView = advertiserLabel
+
+        iconImageView.image = nativeAd.icon?.image
+        iconImageView.contentMode = .scaleAspectFill
+        iconImageView.clipsToBounds = true
+        iconImageView.isHidden = nativeAd.icon == nil
+        addSubview(iconImageView)
+        iconView = iconImageView
+
+        actionButton.setTitle(nativeAd.callToAction, for: .normal)
+        actionButton.titleLabel?.font = .systemFont(
+            ofSize: fontSize(style["callToActionFontSize"], fallback: 13, range: 12 ... 18)
+        )
+        actionButton.setTitleColor(color(style["callToActionTextColor"] as? String) ?? .white, for: .normal)
+        actionButton.backgroundColor = color(style["callToActionBackgroundColor"] as? String) ?? UIColor(
+            red: 33 / 255,
+            green: 150 / 255,
+            blue: 243 / 255,
+            alpha: 1
+        )
+        actionButton.isUserInteractionEnabled = false
+        actionButton.isHidden = nativeAd.callToAction == nil
+        addSubview(actionButton)
+        callToActionView = actionButton
+
+        configureMedia(nativeAd)
+
+        self.nativeAd = nativeAd
+    }
+
+    private func configureAttribution() {
+        attributionLabel.text = "Ad"
+        attributionLabel.textAlignment = .center
+        attributionLabel.font = .boldSystemFont(ofSize: 10)
+        attributionLabel.textColor = .white
+        attributionLabel.backgroundColor = .darkGray
+        addSubview(attributionLabel)
+    }
+
+    private func configureMedia(_ nativeAd: NativeAd) {
+        guard !isSmall else { return }
+        nativeMediaView.mediaContent = nativeAd.mediaContent
+        nativeMediaView.contentMode = .scaleAspectFit
+        nativeMediaView.clipsToBounds = true
+        addSubview(nativeMediaView)
+        mediaView = nativeMediaView
+    }
+
+    private func color(_ value: String?) -> UIColor? {
+        guard var value = value?.trimmingCharacters(in: .whitespacesAndNewlines) else { return nil }
+        if value.hasPrefix("#") { value.removeFirst() }
+        guard value.count == 6 || value.count == 8, let number = UInt64(value, radix: 16) else { return nil }
+        if value.count == 8 {
+            return UIColor(
+                red: CGFloat((number >> 24) & 0xff) / 255,
+                green: CGFloat((number >> 16) & 0xff) / 255,
+                blue: CGFloat((number >> 8) & 0xff) / 255,
+                alpha: CGFloat(number & 0xff) / 255
+            )
+        }
+        return UIColor(
+            red: CGFloat((number >> 16) & 0xff) / 255,
+            green: CGFloat((number >> 8) & 0xff) / 255,
+            blue: CGFloat(number & 0xff) / 255,
+            alpha: 1
+        )
+    }
+
+    private func number(_ value: Any?, fallback: CGFloat) -> CGFloat {
+        max(0, CGFloat((value as? NSNumber)?.doubleValue ?? Double(fallback)))
+    }
+
+    private func fontSize(_ value: Any?, fallback: CGFloat, range: ClosedRange<CGFloat>) -> CGFloat {
+        min(range.upperBound, max(range.lowerBound, number(value, fallback: fallback)))
+    }
+}

package/ios/Sources/AdMobPlugin/Rewarded/AdRewardExecutor.swift

@@ -97,6 +97,7 @@ class AdRewardExecutor: NSObject, FullScreenContentDelegate {
     }
 
     func ad(_ ad: FullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        self.plugin?.resumeWebMedia(for: ad)
         removeCurrentlyShowingAd()
         NSLog("RewardFullScreenDelegate Ad failed to present full screen content with error \(error.localizedDescription).")
         self.plugin?.notifyListeners(RewardAdPluginEvents.FailedToShow.rawValue, data: [
@@ -106,6 +107,7 @@ class AdRewardExecutor: NSObject, FullScreenContentDelegate {
     }
 
     func adWillPresentFullScreenContent(_ ad: FullScreenPresentingAd) {
+        self.plugin?.suspendWebMedia(for: ad)
         NSLog("RewardFullScreenDelegate Ad did present full screen content.")
         self.plugin?.notifyListeners(RewardAdPluginEvents.Showed.rawValue, data: [:])
     }
@@ -115,6 +117,7 @@ class AdRewardExecutor: NSObject, FullScreenContentDelegate {
     }
 
     func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) {
+        self.plugin?.resumeWebMedia(for: ad)
         removeCurrentlyShowingAd()
         NSLog("RewardFullScreenDelegate Ad did dismiss full screen content.")
         self.plugin?.notifyListeners(RewardAdPluginEvents.Dismissed.rawValue, data: [:])

package/ios/Sources/AdMobPlugin/RewardedInterstitial/AdRewardInterstitialExecutor.swift

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

package/ios/Tests/AdMobPluginTests/AdMobPluginTests.swift

@@ -1,15 +1,87 @@
 import XCTest
 @testable import AdMobPlugin
 
-class AdMobTests: XCTestCase {
-    func testEcho() {
-        // This is an example of a functional test case for a plugin.
-        // Use XCTAssert and related functions to verify your tests produce the correct results.
-
-        //         let implementation = AdMob()
-        //         let value = "Hello, World!"
-        //         let result = implementation.echo(value)
-        //
-        //         XCTAssertEqual(value, result)
+final class AdMobPluginTests: XCTestCase {
+    @MainActor
+    func testNormalSuspensionAndResume() async {
+        await checkSuspensions([(0, true, true), (0, false, false)])
+    }
+
+    @MainActor
+    func testFailedAdCannotReleaseAnotherAdsSuspension() async {
+        await checkSuspensions([(0, true, true), (1, false, nil), (0, false, false)])
+    }
+
+    @MainActor
+    func testOnlyLastAdResumesMedia() async {
+        await checkSuspensions([(0, true, true), (1, true, nil), (0, false, nil), (1, false, false)])
+    }
+
+    @MainActor
+    private func checkSuspensions(_ steps: [(Int, Bool, Bool?)]) async {
+        let plugin = MediaTestPlugin()
+        let owners = [NSObject(), NSObject()]
+
+        for (owner, suspend, expected) in steps {
+            let called = expectation(description: "WebKit suspension: \(String(describing: expected))")
+            called.isInverted = expected == nil
+            plugin.onSuspension = { actual in
+                XCTAssertEqual(actual, expected)
+                called.fulfill()
+            }
+            if suspend {
+                plugin.suspendWebMedia(for: owners[owner])
+            } else {
+                plugin.resumeWebMedia(for: owners[owner])
+            }
+            await fulfillment(of: [called], timeout: expected == nil ? 0.1 : 2)
+        }
+        plugin.onSuspension = nil
+    }
+
+    func testNativeFeedSessionsEnforceCapacityAndAllowReplacement() {
+        let sessions = NativeAdFeedSessions()
+
+        XCTAssertTrue(sessions.start(feedId: "first", sessionId: "session-1"))
+        XCTAssertTrue(sessions.start(feedId: "second", sessionId: "session-2"))
+        XCTAssertFalse(sessions.start(feedId: "third", sessionId: "session-3"))
+        XCTAssertTrue(sessions.start(feedId: "first", sessionId: "replacement"))
+        XCTAssertTrue(sessions.isCurrent(feedId: "first", sessionId: "replacement"))
+    }
+
+    func testNativeFeedSessionsRejectStalePlacementSequences() {
+        let sessions = NativeAdFeedSessions()
+        XCTAssertTrue(sessions.start(feedId: "feed", sessionId: "session"))
+
+        XCTAssertTrue(sessions.accepts(feedId: "feed", sequence: 1))
+        XCTAssertFalse(sessions.accepts(feedId: "feed", sequence: 1))
+        XCTAssertFalse(sessions.accepts(feedId: "feed", sequence: 0))
+        XCTAssertTrue(sessions.accepts(feedId: "feed", sequence: 2))
+    }
+
+    func testNativePlacementRejectsWrongFeedAndMalformedRect() {
+        let valid: [String: Any] = [
+            "visible": true,
+            "feedId": "feed",
+            "slotKey": "slot",
+            "generation": 1,
+            "rect": ["x": 0, "y": 0, "width": 144, "height": 300],
+            "clipRect": ["x": 0, "y": 0, "width": 144, "height": 300]
+        ]
+
+        XCTAssertNotNil(NativeAdPlacementValue(valid, expectedFeedId: "feed"))
+        XCTAssertNil(NativeAdPlacementValue(valid, expectedFeedId: "another-feed"))
+        var malformed = valid
+        malformed["rect"] = ["x": 0, "y": 0, "width": 0, "height": 300]
+        XCTAssertNil(NativeAdPlacementValue(malformed, expectedFeedId: "feed"))
+    }
+}
+
+private final class MediaTestPlugin: AdMobPlugin {
+    var onSuspension: ((Bool) -> Void)?
+
+    @MainActor
+    override func setWebMediaPlaybackSuspended(_ suspended: Bool) {
+        onSuspension?(suspended)
     }
 }

package/ios/Tests/AdMobPluginTests/NativeAdScrollTrackerTests.swift

@@ -0,0 +1,47 @@
+import XCTest
+import WebKit
+@testable import AdMobPlugin
+
+final class NativeAdScrollTrackerTests: XCTestCase {
+    @MainActor
+    func testScrollClipsPlacementsAndReleasingTrackerStopsUpdates() throws {
+        let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 320, height: 640))
+        let web = WKWebView(frame: window.bounds)
+        window.addSubview(web)
+        let scroll = UIScrollView(frame: CGRect(x: 0, y: 80, width: 320, height: 500))
+        scroll.contentSize = CGSize(width: 320, height: 1200)
+        web.addSubview(scroll)
+        let placement = try XCTUnwrap(NativeAdPlacementValue([
+            "feedId": "feed", "slotKey": "ad", "generation": 1, "visible": true,
+            "rect": ["x": 10, "y": 400, "width": 300, "height": 320],
+            "clipRect": ["x": 10, "y": 400, "width": 300, "height": 320]
+        ], expectedFeedId: "feed"))
+        let container: [String: Any] = [
+            "rect": ["x": 0, "y": 80, "width": 320, "height": 500],
+            "clipRect": ["x": 0, "y": 100, "width": 320, "height": 480],
+            "contentWidth": 320.0, "contentHeight": 1200.0
+        ]
+        var rendered: [NativeAdPlacementValue] = []
+        var updates = 0
+        var tracker: NativeAdScrollTracker? = try XCTUnwrap(NativeAdScrollTracker(
+            container: container, webView: web, placements: [placement],
+            render: { rendered = $0; updates += 1 }
+        ))
+        tracker?.update()
+        XCTAssertEqual(rendered.first?.clip, CGRect(x: 10, y: 480, width: 300, height: 100))
+        scroll.contentOffset.y = 450
+        XCTAssertEqual(rendered.first?.rect, CGRect(x: 10, y: 30, width: 300, height: 320))
+        XCTAssertEqual(rendered.first?.clip, CGRect(x: 10, y: 100, width: 300, height: 250))
+        scroll.contentOffset.y = 800
+        XCTAssertTrue(rendered.isEmpty)
+        tracker = nil
+        let previousUpdates = updates
+        scroll.contentOffset.y = 0
+        XCTAssertEqual(updates, previousUpdates)
+
+        let duplicate = UIScrollView(frame: scroll.frame)
+        duplicate.contentSize = scroll.contentSize
+        web.addSubview(duplicate)
+        XCTAssertNil(NativeAdScrollTracker(container: container, webView: web, placements: [placement], render: { _ in }))
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capacitor-community/admob",
   "private": false,
-  "version": "8.2.0",
+  "version": "8.2.1",
   "description": "A native plugin for AdMob",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -33,6 +33,7 @@
   "scripts": {
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
     "verify:ios": "xcodebuild -scheme CapacitorCommunityAdmob -destination generic/platform=iOS",
+    "test:ios": "xcodebuild test -scheme CapacitorCommunityAdmob",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "npm run build",
     "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",