cordova-admob-tomitank 1.0.0

package/src/ios/AMBCore.swift

@@ -0,0 +1,232 @@
+import Foundation
+import UIKit
+import GoogleMobileAds
+
+enum AMBCoreError: Error {
+    case notImplemented
+    case unknown
+}
+
+protocol AMBHelperAdapter {
+}
+
+extension AMBHelperAdapter {
+}
+
+class AMBHelper {
+    static let window = UIApplication.shared.keyWindow!
+
+    static var topAnchor: NSLayoutYAxisAnchor {
+        if #available(iOS 11.0, *) {
+            return window.safeAreaLayoutGuide.topAnchor
+        } else {
+            return window.topAnchor
+        }
+    }
+
+    static var bottomAnchor: NSLayoutYAxisAnchor {
+        if #available(iOS 11.0, *) {
+            return window.safeAreaLayoutGuide.bottomAnchor
+        } else {
+            return window.bottomAnchor
+        }
+    }
+
+    static var frame: CGRect {
+        if #available(iOS 11.0, *) {
+            return window.frame.inset(by: window.safeAreaInsets)
+        } else {
+            return window.frame
+        }
+    }
+
+    let adapter: AMBHelperAdapter
+
+    init(_ adapter: AMBHelperAdapter) {
+        self.adapter = adapter
+    }
+}
+
+protocol AMBCoreContext {
+    func has(_ name: String) -> Bool
+    func optBool(_ name: String) -> Bool?
+    func optFloat(_ name: String) -> Float?
+    func optInt(_ name: String) -> Int?
+    func optString(_ name: String, _ defaultValue: String) -> String
+    func optStringArray(_ name: String) -> [String]?
+
+    func resolve(_ data: [String: Any])
+    func resolve(_ data: Bool)
+
+    func reject(_ msg: String)
+}
+
+extension AMBCoreContext {
+    func optString(_ name: String) -> String? {
+        if has(name) {
+            return optString(name, "")
+        }
+        return nil
+    }
+
+    func optAppMuted() -> Bool? {
+        return optBool("appMuted")
+    }
+
+    func optAppVolume() -> Float? {
+        return optFloat("appVolume")
+    }
+
+    func optId() -> Int? {
+        return optInt("id")
+    }
+
+    func optPosition() -> String {
+        return optString("position", "bottom")
+    }
+
+    func optAdUnitID() -> String? {
+        return optString("adUnitId")
+    }
+
+    func optAd() -> AMBCoreAd? {
+        guard let id = optId(),
+              let ad = AMBCoreAd.ads[id]
+        else {
+            return nil
+        }
+        return ad
+    }
+
+    func optAdOrError() -> AMBCoreAd? {
+        if let ad = optAd() {
+            return ad
+        } else {
+            reject("Ad not found: \(optId() ?? -1)")
+            return nil
+        }
+    }
+
+    func optMaxAdContentRating() -> GADMaxAdContentRating? {
+        switch optString("maxAdContentRating") {
+        case "G":
+            return GADMaxAdContentRating.general
+        case "MA":
+            return GADMaxAdContentRating.matureAudience
+        case "PG":
+            return GADMaxAdContentRating.parentalGuidance
+        case "T":
+            return GADMaxAdContentRating.teen
+        default:
+            return nil
+        }
+    }
+
+    func optChildDirectedTreatmentTag() -> Bool? {
+        return optBool("tagForChildDirectedTreatment")
+    }
+
+    func optUnderAgeOfConsentTag() -> Bool? {
+        return optBool("tagForUnderAgeOfConsent")
+    }
+
+    func optTestDeviceIds() -> [String]? {
+        return optStringArray("testDeviceIds")
+    }
+
+    func optGADRequest() -> GADRequest {
+        let request = GADRequest()
+        if let contentURL = optString("contentUrl") {
+            request.contentURL = contentURL
+        }
+        if let keywords = optStringArray("keywords") {
+            request.keywords = keywords
+        }
+        let extras = GADExtras()
+        if let npa = optString("npa") {
+            extras.additionalParameters = ["npa": npa]
+        }
+        request.register(extras)
+        return request
+    }
+
+    func resolve() {
+        resolve([:])
+    }
+
+    func resolve(_ data: Bool) {
+        resolve(["value": data])
+    }
+
+    func reject() {
+        return reject(AMBCoreError.unknown)
+    }
+
+    func reject(_ error: Error) {
+        reject(error.localizedDescription)
+    }
+
+    func configure() {
+        if let muted = optAppMuted() {
+            GADMobileAds.sharedInstance().applicationMuted = muted
+        }
+        if let volume = optAppVolume() {
+            GADMobileAds.sharedInstance().applicationVolume = volume
+        }
+
+        let requestConfiguration = GADMobileAds.sharedInstance().requestConfiguration
+        if let maxAdContentRating = optMaxAdContentRating() {
+            requestConfiguration.maxAdContentRating = maxAdContentRating
+        }
+        if let tag = optChildDirectedTreatmentTag() {
+            requestConfiguration.tag(forChildDirectedTreatment: tag)
+        }
+        if let tag = optUnderAgeOfConsentTag() {
+            requestConfiguration.tagForUnderAge(ofConsent: tag)
+        }
+        if let testDevices = optTestDeviceIds() {
+            requestConfiguration.testDeviceIdentifiers = testDevices
+        }
+        if let sameAppKey = optBool("sameAppKey") {
+            requestConfiguration.setSameAppKeyEnabled(sameAppKey)
+        }
+
+        resolve()
+    }
+}
+
+class AMBCoreAd: NSObject {
+    static var ads = [Int: AMBCoreAd]()
+
+    let id: Int
+    let adUnitId: String
+    let adRequest: GADRequest
+
+    init(id: Int, adUnitId: String, adRequest: GADRequest) {
+        self.id = id
+        self.adUnitId = adUnitId
+        self.adRequest = adRequest
+
+        super.init()
+
+        AMBCoreAd.ads[id] = self
+    }
+
+    convenience init?(_ ctx: AMBCoreContext) {
+        guard let id = ctx.optId(),
+              let adUnitId = ctx.optAdUnitID()
+        else {
+            return nil
+        }
+        self.init(id: id, adUnitId: adUnitId, adRequest: ctx.optGADRequest())
+    }
+
+    deinit {
+        let key = self.id
+        DispatchQueue.main.async {
+            AMBCoreAd.ads.removeValue(forKey: key)
+        }
+    }
+}
+
+class AMBBannerPlaceholder: UIView {}

package/src/ios/AMBGenerated.swift

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

package/src/ios/AMBInterstitial.swift

@@ -0,0 +1,69 @@
+import GoogleMobileAds
+
+class AMBInterstitial: AMBAdBase, GADFullScreenContentDelegate {
+    var mAd: GADInterstitialAd?
+
+    deinit {
+        clear()
+    }
+
+    override func isLoaded() -> Bool {
+        return self.mAd != nil
+    }
+
+    override func load(_ ctx: AMBContext) {
+        clear()
+
+        GADInterstitialAd.load(
+            withAdUnitID: adUnitId,
+            request: adRequest,
+            completionHandler: { ad, error in
+                if error != nil {
+                    self.emit(AMBEvents.adLoadFail, error!)
+                    self.emit(AMBEvents.interstitialLoadFail, error!)
+                    ctx.reject(error!)
+                    return
+                }
+
+                self.mAd = ad
+                ad?.fullScreenContentDelegate = self
+
+                self.emit(AMBEvents.adLoad)
+                self.emit(AMBEvents.interstitialLoad)
+
+                ctx.resolve()
+         })
+    }
+
+    override func show(_ ctx: AMBContext) {
+        mAd?.present(fromRootViewController: plugin.viewController)
+        ctx.resolve()
+    }
+
+    func adDidRecordImpression(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adImpression)
+        self.emit(AMBEvents.interstitialImpression)
+    }
+
+    func ad(_ ad: GADFullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) {
+        clear()
+        self.emit(AMBEvents.adShowFail, error)
+        self.emit(AMBEvents.interstitialShowFail, error)
+    }
+
+    func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        self.emit(AMBEvents.adShow)
+        self.emit(AMBEvents.interstitialShow)
+    }
+
+    func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
+        clear()
+        self.emit(AMBEvents.adDismiss)
+        self.emit(AMBEvents.interstitialDismiss)
+    }
+
+    private func clear() {
+        mAd?.fullScreenContentDelegate = nil
+        mAd = nil
+    }
+}

package/src/ios/AMBNativeAd.swift

@@ -0,0 +1,128 @@
+import Foundation
+import GoogleMobileAds
+
+protocol AMBNativeAdViewProvider: NSObjectProtocol {
+    func createView(_ nativeAd: GADNativeAd) -> UIView
+    // delegate
+    func didShow(_ ad: AMBNativeAd)
+    func didHide(_ ad: AMBNativeAd)
+}
+
+extension AMBNativeAdViewProvider {
+    func didShow(_ ad: AMBNativeAd) {}
+    func didHide(_ ad: AMBNativeAd) {}
+}
+
+class AMBNativeAd: AMBAdBase, GADNativeAdLoaderDelegate, GADNativeAdDelegate {
+    static var providers = [String: AMBNativeAdViewProvider]()
+
+    var mLoader: GADAdLoader!
+    let viewProvider: AMBNativeAdViewProvider
+    var mAd: GADNativeAd?
+    var ctxLoad: AMBContext?
+
+    lazy var view: UIView = {
+        return viewProvider.createView(mAd!)
+    }()
+
+    init(id: Int, adUnitId: String, adRequest: GADRequest, viewProvider: AMBNativeAdViewProvider) {
+        self.viewProvider = viewProvider
+
+        super.init(id: id, adUnitId: adUnitId, adRequest: adRequest)
+
+        mLoader = GADAdLoader(adUnitID: adUnitId, rootViewController: plugin.viewController,
+                              adTypes: [.native], options: nil)
+        mLoader.delegate = self
+    }
+
+    convenience init?(_ ctx: AMBContext) {
+        let view = ctx.optString("view") ?? "default"
+        guard let id = ctx.optId(),
+              let adUnitId = ctx.optAdUnitID(),
+              let viewProvider = Self.providers[view]
+        else {
+            return nil
+        }
+        self.init(id: id,
+                  adUnitId: adUnitId,
+                  adRequest: ctx.optGADRequest(),
+                  viewProvider: viewProvider)
+    }
+
+    override func load(_ ctx: AMBContext) {
+        ctxLoad = ctx
+        mLoader.load(adRequest)
+    }
+
+    override func isLoaded() -> Bool {
+        if mLoader == nil {
+            return false
+        }
+        return !mLoader.isLoading
+    }
+
+    override func show(_ ctx: AMBContext) {
+        if let x = ctx.opt("x") as? Double,
+           let y = ctx.opt("y") as? Double,
+           let w = ctx.opt("width") as? Double,
+           let h = ctx.opt("height") as? Double {
+            view.frame = CGRect(x: x, y: y, width: w, height: h)
+        }
+
+        if let rootView = plugin.viewController.view, view.superview != rootView {
+            rootView.addSubview(view)
+        }
+        view.isHidden = false
+
+        viewProvider.didShow(self)
+    }
+
+    override func hide(_ ctx: AMBContext) {
+        view.isHidden = true
+        viewProvider.didHide(self)
+        ctx.resolve()
+    }
+
+    func adLoader(_ adLoader: GADAdLoader, didReceive nativeAd: GADNativeAd) {
+        mAd = nativeAd
+        nativeAd.delegate = self
+        self.emit(AMBEvents.adLoad)
+        if !adLoader.isLoading {
+            ctxLoad?.resolve()
+            ctxLoad = nil
+        }
+    }
+
+    func adLoader(_ adLoader: GADAdLoader, didFailToReceiveAdWithError error: Error) {
+        self.emit(AMBEvents.adLoadFail, error)
+        if !adLoader.isLoading {
+            ctxLoad?.reject(error)
+            ctxLoad = nil
+        }
+    }
+
+    func nativeAdDidRecordImpression(_ nativeAd: GADNativeAd) {
+        self.emit(AMBEvents.adImpression, nativeAd)
+    }
+
+    func nativeAdDidRecordClick(_ nativeAd: GADNativeAd) {
+        self.emit(AMBEvents.adClick, nativeAd)
+    }
+
+    func nativeAdWillPresentScreen(_ nativeAd: GADNativeAd) {
+        self.emit(AMBEvents.adShow, nativeAd)
+    }
+
+    func nativeAdWillDismissScreen(_ nativeAd: GADNativeAd) {
+        // The native ad will dismiss a full screen view.
+    }
+
+    func nativeAdDidDismissScreen(_ nativeAd: GADNativeAd) {
+        self.emit(AMBEvents.adDismiss, nativeAd)
+    }
+
+    func nativeAdWillLeaveApplication(_ nativeAd: GADNativeAd) {
+        // The native ad will cause the application to become inactive and
+        // open a new application.
+    }
+}

package/src/ios/AMBPlugin.swift

@@ -0,0 +1,198 @@
+#if canImport(AppTrackingTransparency)
+    import AppTrackingTransparency
+#endif
+import GoogleMobileAds
+
+@objc(AMBPlugin)
+class AMBPlugin: CDVPlugin {
+    static func registerNativeAdViewProviders(_ providers: [String: AMBNativeAdViewProvider]) {
+        AMBNativeAd.providers.merge(providers) {(_, new) in new}
+    }
+
+    var readyCallbackId: String!
+
+    deinit {
+        readyCallbackId = nil
+    }
+
+    override func pluginInitialize() {
+        super.pluginInitialize()
+
+        AMBContext.plugin = self
+
+        if let x = self.commandDelegate.settings["disableSDKCrashReporting".lowercased()] as? String,
+           x == "true" {
+            GADMobileAds.sharedInstance().disableSDKCrashReporting()
+        }
+    }
+
+    @objc func ready(_ command: CDVInvokedUrlCommand) {
+        readyCallbackId = command.callbackId
+
+        DispatchQueue.global(qos: .background).async {
+            self.emit(AMBEvents.ready, data: ["isRunningInTestLab": false])
+        }
+    }
+
+    @objc func configure(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+        ctx.configure()
+    }
+
+    @objc func configRequest(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+        let requestConfiguration = GADMobileAds.sharedInstance().requestConfiguration
+
+        if let maxAdContentRating = ctx.optMaxAdContentRating() {
+            requestConfiguration.maxAdContentRating = maxAdContentRating
+        }
+
+        if let tag = ctx.optChildDirectedTreatmentTag() {
+            requestConfiguration.tag(forChildDirectedTreatment: tag)
+        }
+
+        if let tag = ctx.optUnderAgeOfConsentTag() {
+            requestConfiguration.tagForUnderAge(ofConsent: tag)
+        }
+
+        if let testDevices = ctx.optTestDeviceIds() {
+            requestConfiguration.testDeviceIdentifiers = testDevices
+        }
+
+        ctx.resolve()
+    }
+
+    @objc func requestTrackingAuthorization(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        if #available(iOS 14, *) {
+            ATTrackingManager.requestTrackingAuthorization(completionHandler: { status in
+                ctx.resolve(status.rawValue)
+            })
+        } else {
+            ctx.resolve(false)
+        }
+    }
+
+    @objc func start(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        GADMobileAds.sharedInstance().start(completionHandler: { _ in
+            ctx.resolve(["version": GADMobileAds.sharedInstance().sdkVersion])
+        })
+    }
+
+    @objc func setAppMuted(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        if let muted = ctx.opt0() as? Bool {
+            GADMobileAds.sharedInstance().applicationMuted = muted
+            ctx.resolve()
+        } else {
+            ctx.reject()
+        }
+    }
+
+    @objc func setAppVolume(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        if let volume = ctx.opt0() as? Float {
+            GADMobileAds.sharedInstance().applicationVolume = volume
+            ctx.resolve()
+        } else {
+            ctx.reject()
+        }
+    }
+
+    @objc func adCreate(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            if let adClass = ctx.optString("cls") {
+                var ad: AMBCoreAd?
+                switch adClass {
+                case "AppOpenAd":
+                    ad = AMBAppOpenAd(ctx)
+                case "BannerAd":
+                    ad = AMBBanner(ctx)
+                case "InterstitialAd":
+                    ad = AMBInterstitial(ctx)
+                case "NativeAd":
+                    ad = AMBNativeAd(ctx)
+                case "RewardedAd":
+                    ad = AMBRewarded(ctx)
+                case "RewardedInterstitialAd":
+                    ad = AMBRewardedInterstitial(ctx)
+                default:
+                    break
+                }
+                if ad != nil {
+                    ctx.resolve()
+                } else {
+                    ctx.reject("fail to create ad: \(ctx.optId() ?? -1)")
+                }
+            } else {
+                ctx.reject()
+            }
+        }
+    }
+
+    @objc func adIsLoaded(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            if let ad = ctx.optAdOrError() as? AMBAdBase {
+                ctx.resolve(ad.isLoaded())
+            }
+        }
+    }
+
+    @objc func adLoad(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            if let ad = ctx.optAdOrError() as? AMBAdBase {
+                ad.load(ctx)
+            }
+        }
+    }
+
+    @objc func adShow(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            if let ad = ctx.optAdOrError() as? AMBAdBase {
+                if ad.isLoaded() {
+                    ad.show(ctx)
+                    ctx.resolve(true)
+                } else {
+                    ctx.resolve(false)
+                }
+            }
+        }
+    }
+
+    @objc func adHide(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            if let ad = ctx.optAdOrError() as? AMBAdBase {
+                ad.hide(ctx)
+            }
+        }
+    }
+
+    @objc func bannerConfig(_ command: CDVInvokedUrlCommand) {
+        let ctx = AMBContext(command)
+
+        DispatchQueue.main.async {
+            AMBBanner.config(ctx)
+        }
+    }
+
+    func emit(_ eventName: String, data: Any = NSNull()) {
+        let result = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: ["type": eventName, "data": data])
+        result?.setKeepCallbackAs(true)
+        self.commandDelegate.send(result, callbackId: readyCallbackId)
+    }
+}