@capgo/capacitor-admob 7.1.1 → 7.4.4

package/ios/Sources/AdmobPlusPlugin/AdmobPlusPlugin.swift

@@ -1,26 +1,239 @@
 import Capacitor
 import Foundation
+import GoogleMobileAds
+import AppTrackingTransparency
 
 @objc(AdmobPlusPlugin)
 public class AdmobPlusPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let PLUGIN_VERSION: String = "7.1.1"
+    private let pluginVersion: String = "7.4.4"
     public let identifier = "AdmobPlusPlugin"
     public let jsName = "AdMobPlus"
     public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "echo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "configure", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "configRequest", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "adCreate", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "adIsLoaded", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "adLoad", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "adShow", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "adHide", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "trackingAuthorizationStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestTrackingAuthorization", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
     ]
-    private let implementation = AdmobPlus()
 
-    @objc func echo(_ call: CAPPluginCall) {
-        let value = call.getString("value") ?? ""
-        call.resolve([
-            "value": implementation.echo(value)
-        ])
+    private var nextAdId = 1
+    private let adManager = AdManager.shared
+
+    @objc func start(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            GADMobileAds.sharedInstance().start { _ in
+                call.resolve()
+            }
+        }
     }
 
-    @objc func getPluginVersion(_ call: CAPPluginCall) {
-        call.resolve(["version": self.PLUGIN_VERSION])
+    @objc func configure(_ call: CAPPluginCall) {
+        let appMuted = call.getBool("appMuted")
+        let appVolume = call.getFloat("appVolume")
+
+        if let muted = appMuted {
+            GADMobileAds.sharedInstance().applicationMuted = muted
+        }
+
+        if let volume = appVolume {
+            GADMobileAds.sharedInstance().applicationVolume = volume
+        }
+
+        call.resolve()
+    }
+
+    @objc func configRequest(_ call: CAPPluginCall) {
+        let requestConfiguration = GADMobileAds.sharedInstance().requestConfiguration
+
+        if let maxAdContentRating = call.getString("maxAdContentRating") {
+            switch maxAdContentRating {
+            case "G":
+                requestConfiguration.maxAdContentRating = .general
+            case "PG":
+                requestConfiguration.maxAdContentRating = .parentalGuidance
+            case "T":
+                requestConfiguration.maxAdContentRating = .teen
+            case "MA":
+                requestConfiguration.maxAdContentRating = .matureAudience
+            default:
+                break
+            }
+        }
+
+        if let tagForChildDirectedTreatment = call.getBool("tagForChildDirectedTreatment") {
+            requestConfiguration.tagForChildDirectedTreatment = NSNumber(value: tagForChildDirectedTreatment)
+        }
+
+        if let tagForUnderAgeOfConsent = call.getBool("tagForUnderAgeOfConsent") {
+            requestConfiguration.tagForUnderAgeOfConsent = NSNumber(value: tagForUnderAgeOfConsent)
+        }
+
+        if let testDeviceIds = call.getArray("testDeviceIds", String.self) {
+            requestConfiguration.testDeviceIdentifiers = testDeviceIds
+        }
+
+        call.resolve()
     }
 
+    @objc func adCreate(_ call: CAPPluginCall) {
+        guard let adUnitId = call.getString("adUnitId") else {
+            call.reject("adUnitId is required")
+            return
+        }
+
+        guard let adClass = call.getString("cls") else {
+            call.reject("cls (ad class) is required")
+            return
+        }
+
+        let adId = call.getInt("id") ?? nextAdId
+        nextAdId = adId + 1
+
+        let position = call.getString("position") ?? "bottom"
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                call.reject("Plugin instance not available")
+                return
+            }
+
+            let ad: Ad?
+            switch adClass {
+            case "BannerAd":
+                ad = BannerAd(id: adId, adUnitId: adUnitId, position: position, plugin: self)
+            case "InterstitialAd":
+                ad = InterstitialAd(id: adId, adUnitId: adUnitId, plugin: self)
+            case "RewardedAd":
+                ad = RewardedAd(id: adId, adUnitId: adUnitId, plugin: self)
+            case "RewardedInterstitialAd":
+                ad = RewardedInterstitialAd(id: adId, adUnitId: adUnitId, plugin: self)
+            default:
+                call.reject("Unsupported ad class: \(adClass)")
+                return
+            }
+
+            if let ad = ad {
+                self.adManager.addAd(ad, withId: adId)
+                call.resolve(["id": adId])
+            } else {
+                call.reject("Failed to create ad")
+            }
+        }
+    }
+
+    @objc func adIsLoaded(_ call: CAPPluginCall) {
+        guard let adId = call.getInt("id") else {
+            call.reject("id is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let ad = self?.adManager.getAd(adId) else {
+                call.resolve(["value": false])
+                return
+            }
+
+            call.resolve(["value": ad.isLoaded])
+        }
+    }
+
+    @objc func adLoad(_ call: CAPPluginCall) {
+        guard let adId = call.getInt("id") else {
+            call.reject("id is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let ad = self?.adManager.getAd(adId) else {
+                call.reject("Ad not found")
+                return
+            }
+
+            ad.load { error in
+                if let error = error {
+                    call.reject("Failed to load ad: \(error.localizedDescription)")
+                } else {
+                    call.resolve()
+                }
+            }
+        }
+    }
+
+    @objc func adShow(_ call: CAPPluginCall) {
+        guard let adId = call.getInt("id") else {
+            call.reject("id is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let ad = self?.adManager.getAd(adId) else {
+                call.reject("Ad not found")
+                return
+            }
+
+            if !ad.isLoaded {
+                call.reject("Ad is not loaded")
+                return
+            }
+
+            ad.show { error in
+                if let error = error {
+                    call.reject("Failed to show ad: \(error.localizedDescription)")
+                } else {
+                    call.resolve()
+                }
+            }
+        }
+    }
+
+    @objc func adHide(_ call: CAPPluginCall) {
+        guard let adId = call.getInt("id") else {
+            call.reject("id is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let ad = self?.adManager.getAd(adId) else {
+                call.reject("Ad not found")
+                return
+            }
+
+            ad.hide { error in
+                if let error = error {
+                    call.reject("Failed to hide ad: \(error.localizedDescription)")
+                } else {
+                    call.resolve()
+                }
+            }
+        }
+    }
+
+    @objc func trackingAuthorizationStatus(_ call: CAPPluginCall) {
+        if #available(iOS 14, *) {
+            let status = ATTrackingManager.trackingAuthorizationStatus
+            call.resolve(["status": status.rawValue])
+        } else {
+            call.resolve(["status": false])
+        }
+    }
+
+    @objc func requestTrackingAuthorization(_ call: CAPPluginCall) {
+        if #available(iOS 14, *) {
+            ATTrackingManager.requestTrackingAuthorization { status in
+                call.resolve(["status": status.rawValue])
+            }
+        } else {
+            call.resolve(["status": false])
+        }
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve(["version": self.pluginVersion])
+    }
 }

package/ios/Sources/AdmobPlusPlugin/BannerAd.swift

@@ -0,0 +1,143 @@
+import Foundation
+import UIKit
+import GoogleMobileAds
+import Capacitor
+
+class BannerAd: NSObject, Ad {
+    let id: Int
+    let adUnitId: String
+    private var bannerView: GADBannerView?
+    private weak var plugin: AdmobPlusPlugin?
+    private let position: String
+    private var bannerContainer: UIView?
+
+    var isLoaded: Bool {
+        return bannerView != nil
+    }
+
+    init(id: Int, adUnitId: String, position: String, plugin: AdmobPlusPlugin) {
+        self.id = id
+        self.adUnitId = adUnitId
+        self.position = position
+        self.plugin = plugin
+        super.init()
+    }
+
+    func load(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            if self.bannerView == nil {
+                let banner = GADBannerView(adSize: GADAdSizeBanner)
+                banner.adUnitID = self.adUnitId
+                banner.delegate = self
+                banner.rootViewController = self.plugin?.bridge?.viewController
+                self.bannerView = banner
+            }
+
+            let request = AdMobHelper.buildAdRequest()
+            self.bannerView?.load(request)
+            completion(nil)
+        }
+    }
+
+    func show(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let banner = self.bannerView else {
+                completion(AdMobError.adNotLoaded)
+                return
+            }
+
+            guard let webView = self.plugin?.bridge?.webView,
+                  let viewController = self.plugin?.bridge?.viewController else {
+                completion(AdMobError.unknown("Unable to access view hierarchy"))
+                return
+            }
+
+            // Remove existing container if any
+            self.bannerContainer?.removeFromSuperview()
+
+            // Create a new container
+            let container = UIView()
+            container.translatesAutoresizingMaskIntoConstraints = false
+            banner.translatesAutoresizingMaskIntoConstraints = false
+
+            container.addSubview(banner)
+
+            // Add container to the view hierarchy
+            viewController.view.addSubview(container)
+
+            // Setup constraints
+            NSLayoutConstraint.activate([
+                container.leadingAnchor.constraint(equalTo: viewController.view.leadingAnchor),
+                container.trailingAnchor.constraint(equalTo: viewController.view.trailingAnchor),
+                container.heightAnchor.constraint(equalToConstant: 50),
+
+                banner.centerXAnchor.constraint(equalTo: container.centerXAnchor),
+                banner.centerYAnchor.constraint(equalTo: container.centerYAnchor)
+            ])
+
+            if self.position == "top" {
+                NSLayoutConstraint.activate([
+                    container.topAnchor.constraint(equalTo: viewController.view.safeAreaLayoutGuide.topAnchor)
+                ])
+            } else {
+                NSLayoutConstraint.activate([
+                    container.bottomAnchor.constraint(equalTo: viewController.view.safeAreaLayoutGuide.bottomAnchor)
+                ])
+            }
+
+            self.bannerContainer = container
+            container.isHidden = false
+            banner.isHidden = false
+
+            completion(nil)
+        }
+    }
+
+    func hide(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.bannerContainer?.isHidden = true
+            self?.bannerView?.isHidden = true
+            completion(nil)
+        }
+    }
+
+    func destroy() {
+        DispatchQueue.main.async { [weak self] in
+            self?.bannerContainer?.removeFromSuperview()
+            self?.bannerView?.removeFromSuperview()
+            self?.bannerView = nil
+            self?.bannerContainer = nil
+        }
+    }
+}
+
+extension BannerAd: GADBannerViewDelegate {
+    func bannerViewDidReceiveAd(_ bannerView: GADBannerView) {
+        plugin?.notifyListeners(Events.bannerLoad, data: ["id": id])
+    }
+
+    func bannerView(_ bannerView: GADBannerView, didFailToReceiveAdWithError error: Error) {
+        plugin?.notifyListeners(Events.bannerLoadFail, data: [
+            "id": id,
+            "error": error.localizedDescription
+        ])
+    }
+
+    func bannerViewDidRecordImpression(_ bannerView: GADBannerView) {
+        plugin?.notifyListeners(Events.bannerImpression, data: ["id": id])
+    }
+
+    func bannerViewWillPresentScreen(_ bannerView: GADBannerView) {
+        plugin?.notifyListeners(Events.bannerOpen, data: ["id": id])
+    }
+
+    func bannerViewWillDismissScreen(_ bannerView: GADBannerView) {
+        plugin?.notifyListeners(Events.bannerClose, data: ["id": id])
+    }
+
+    func bannerViewDidRecordClick(_ bannerView: GADBannerView) {
+        plugin?.notifyListeners(Events.bannerClick, data: ["id": id])
+    }
+}

package/ios/Sources/AdmobPlusPlugin/Generated.swift

@@ -0,0 +1,40 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+import Foundation
+
+struct Events {
+    static let adClick = "ad.click"
+    static let adDismiss = "ad.dismiss"
+    static let adImpression = "ad.impression"
+    static let adLoad = "ad.load"
+    static let adLoadFail = "ad.loadfail"
+    static let adReward = "ad.reward"
+    static let adShow = "ad.show"
+    static let adShowFail = "ad.showfail"
+    static let bannerClick = "banner.click"
+    static let bannerClose = "banner.close"
+    static let bannerImpression = "banner.impression"
+    static let bannerLoad = "banner.load"
+    static let bannerLoadFail = "banner.loadfail"
+    static let bannerOpen = "banner.open"
+    static let bannerSizeChange = "banner.sizechange"
+    static let interstitialDismiss = "interstitial.dismiss"
+    static let interstitialImpression = "interstitial.impression"
+    static let interstitialLoad = "interstitial.load"
+    static let interstitialLoadFail = "interstitial.loadfail"
+    static let interstitialShow = "interstitial.show"
+    static let interstitialShowFail = "interstitial.showfail"
+    static let rewardedDismiss = "rewarded.dismiss"
+    static let rewardedImpression = "rewarded.impression"
+    static let rewardedInterstitialDismiss = "rewardedi.dismiss"
+    static let rewardedInterstitialImpression = "rewardedi.impression"
+    static let rewardedInterstitialLoad = "rewardedi.load"
+    static let rewardedInterstitialLoadFail = "rewardedi.loadfail"
+    static let rewardedInterstitialReward = "rewardedi.reward"
+    static let rewardedInterstitialShow = "rewardedi.show"
+    static let rewardedInterstitialShowFail = "rewardedi.showfail"
+    static let rewardedLoad = "rewarded.load"
+    static let rewardedLoadFail = "rewarded.loadfail"
+    static let rewardedReward = "rewarded.reward"
+    static let rewardedShow = "rewarded.show"
+    static let rewardedShowFail = "rewarded.showfail"
+}

package/ios/Sources/AdmobPlusPlugin/Helper.swift

@@ -0,0 +1,68 @@
+import Foundation
+import GoogleMobileAds
+
+class AdManager {
+    static let shared = AdManager()
+    private var ads: [Int: Ad] = [:]
+
+    private init() {}
+
+    func addAd(_ ad: Ad, withId id: Int) {
+        ads[id] = ad
+    }
+
+    func getAd(_ id: Int) -> Ad? {
+        return ads[id]
+    }
+
+    func removeAd(_ id: Int) {
+        ads.removeValue(forKey: id)
+    }
+}
+
+protocol Ad {
+    var id: Int { get }
+    var adUnitId: String { get }
+    var isLoaded: Bool { get }
+
+    func load(completion: @escaping (Error?) -> Void)
+    func show(completion: @escaping (Error?) -> Void)
+    func hide(completion: @escaping (Error?) -> Void)
+    func destroy()
+}
+
+extension Ad {
+    func hide(completion: @escaping (Error?) -> Void) {
+        completion(NSError(domain: "AdMobPlus", code: -1, userInfo: [NSLocalizedDescriptionKey: "Hide not supported for this ad type"]))
+    }
+}
+
+class AdMobHelper {
+    static func buildAdRequest() -> GADRequest {
+        let request = GADRequest()
+        return request
+    }
+}
+
+enum AdMobError: Error {
+    case adNotFound
+    case adNotLoaded
+    case adAlreadyExists
+    case invalidAdType
+    case unknown(String)
+
+    var localizedDescription: String {
+        switch self {
+        case .adNotFound:
+            return "Ad not found"
+        case .adNotLoaded:
+            return "Ad is not loaded"
+        case .adAlreadyExists:
+            return "Ad already exists"
+        case .invalidAdType:
+            return "Invalid ad type"
+        case .unknown(let message):
+            return message
+        }
+    }
+}

package/ios/Sources/AdmobPlusPlugin/InterstitialAd.swift

@@ -0,0 +1,92 @@
+import Foundation
+import UIKit
+import GoogleMobileAds
+import Capacitor
+
+class InterstitialAd: NSObject, Ad {
+    let id: Int
+    let adUnitId: String
+    private var interstitial: GADInterstitialAd?
+    private weak var plugin: AdmobPlusPlugin?
+
+    var isLoaded: Bool {
+        return interstitial != nil
+    }
+
+    init(id: Int, adUnitId: String, plugin: AdmobPlusPlugin) {
+        self.id = id
+        self.adUnitId = adUnitId
+        self.plugin = plugin
+        super.init()
+    }
+
+    func load(completion: @escaping (Error?) -> Void) {
+        let request = AdMobHelper.buildAdRequest()
+
+        GADInterstitialAd.load(withAdUnitID: adUnitId, request: request) { [weak self] ad, error in
+            guard let self = self else { return }
+
+            if let error = error {
+                self.plugin?.notifyListeners(Events.interstitialLoadFail, data: [
+                    "id": self.id,
+                    "error": error.localizedDescription
+                ])
+                completion(error)
+                return
+            }
+
+            self.interstitial = ad
+            self.interstitial?.fullScreenContentDelegate = self
+
+            self.plugin?.notifyListeners(Events.interstitialLoad, data: ["id": self.id])
+            completion(nil)
+        }
+    }
+
+    func show(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let interstitial = self.interstitial else {
+                completion(AdMobError.adNotLoaded)
+                return
+            }
+
+            guard let viewController = self.plugin?.bridge?.viewController else {
+                completion(AdMobError.unknown("Unable to access view controller"))
+                return
+            }
+
+            interstitial.present(fromRootViewController: viewController)
+            completion(nil)
+        }
+    }
+
+    func destroy() {
+        interstitial = nil
+    }
+}
+
+extension InterstitialAd: GADFullScreenContentDelegate {
+    func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.interstitialImpression, data: ["id": id])
+    }
+
+    func adDidRecordClick(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.adClick, data: ["id": id])
+    }
+
+    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        plugin?.notifyListeners(Events.interstitialShowFail, data: [
+            "id": id,
+            "error": error.localizedDescription
+        ])
+    }
+
+    func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.interstitialShow, data: ["id": id])
+    }
+
+    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.interstitialDismiss, data: ["id": id])
+        interstitial = nil
+    }
+}

package/ios/Sources/AdmobPlusPlugin/RewardedAd.swift

@@ -0,0 +1,102 @@
+import Foundation
+import UIKit
+import GoogleMobileAds
+import Capacitor
+
+class RewardedAd: NSObject, Ad {
+    let id: Int
+    let adUnitId: String
+    private var rewardedAd: GADRewardedAd?
+    private weak var plugin: AdmobPlusPlugin?
+
+    var isLoaded: Bool {
+        return rewardedAd != nil
+    }
+
+    init(id: Int, adUnitId: String, plugin: AdmobPlusPlugin) {
+        self.id = id
+        self.adUnitId = adUnitId
+        self.plugin = plugin
+        super.init()
+    }
+
+    func load(completion: @escaping (Error?) -> Void) {
+        let request = AdMobHelper.buildAdRequest()
+
+        GADRewardedAd.load(withAdUnitID: adUnitId, request: request) { [weak self] ad, error in
+            guard let self = self else { return }
+
+            if let error = error {
+                self.plugin?.notifyListeners(Events.rewardedLoadFail, data: [
+                    "id": self.id,
+                    "error": error.localizedDescription
+                ])
+                completion(error)
+                return
+            }
+
+            self.rewardedAd = ad
+            self.rewardedAd?.fullScreenContentDelegate = self
+
+            self.plugin?.notifyListeners(Events.rewardedLoad, data: ["id": self.id])
+            completion(nil)
+        }
+    }
+
+    func show(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let rewardedAd = self.rewardedAd else {
+                completion(AdMobError.adNotLoaded)
+                return
+            }
+
+            guard let viewController = self.plugin?.bridge?.viewController else {
+                completion(AdMobError.unknown("Unable to access view controller"))
+                return
+            }
+
+            rewardedAd.present(fromRootViewController: viewController) { [weak self] in
+                guard let self = self else { return }
+                let reward = rewardedAd.adReward
+                self.plugin?.notifyListeners(Events.rewardedReward, data: [
+                    "id": self.id,
+                    "reward": [
+                        "amount": reward.amount.intValue,
+                        "type": reward.type
+                    ]
+                ])
+            }
+            completion(nil)
+        }
+    }
+
+    func destroy() {
+        rewardedAd = nil
+    }
+}
+
+extension RewardedAd: GADFullScreenContentDelegate {
+    func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.rewardedImpression, data: ["id": id])
+    }
+
+    func adDidRecordClick(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.adClick, data: ["id": id])
+    }
+
+    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        plugin?.notifyListeners(Events.rewardedShowFail, data: [
+            "id": id,
+            "error": error.localizedDescription
+        ])
+    }
+
+    func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.rewardedShow, data: ["id": id])
+    }
+
+    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        plugin?.notifyListeners(Events.rewardedDismiss, data: ["id": id])
+        rewardedAd = nil
+    }
+}