@capgo/capacitor-admob 7.0.0

package/android/src/main/kotlin/admob/plus/capacitor/ads/Banner.kt

@@ -0,0 +1,148 @@
+package admob.plus.capacitor.ads
+
+import admob.plus.capacitor.AdMobPlusPlugin
+import admob.plus.capacitor.ExecuteContext
+import admob.plus.capacitor.Generated
+import admob.plus.core.Context
+import admob.plus.core.GenericAd
+import admob.plus.core.Helper.Companion.getParentView
+import admob.plus.core.Helper.Companion.removeFromParentView
+import android.annotation.SuppressLint
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import android.widget.LinearLayout
+import com.google.android.gms.ads.AdListener
+import com.google.android.gms.ads.AdSize
+import com.google.android.gms.ads.AdView
+import com.google.android.gms.ads.LoadAdError
+import java.util.Objects
+
+class Banner(ctx: ExecuteContext) : AdBase(ctx), GenericAd {
+    private val adSize: AdSize
+    private val gravity: Int
+    private var adView: AdView? = null
+
+    init {
+        adSize = AdSize.SMART_BANNER
+        gravity = if ("top" == ctx.optPosition()) Gravity.TOP else Gravity.BOTTOM
+    }
+
+    override val isLoaded: Boolean
+        get() = adView != null
+
+    override fun load(ctx: Context?) {
+        if (adView == null) {
+            adView = AdView(activity)
+            adView!!.adUnitId = adUnitId
+            // adView!!.adSize = adSize
+            adView!!.adListener = object : AdListener() {
+                override fun onAdClicked() {
+                    emit(Generated.Events.BANNER_CLICK)
+                }
+
+                override fun onAdClosed() {
+                    emit(Generated.Events.BANNER_CLOSE)
+                }
+
+                override fun onAdFailedToLoad(error: LoadAdError) {
+                    emit(Generated.Events.BANNER_LOAD_FAIL, error)
+                }
+
+                override fun onAdImpression() {
+                    emit(Generated.Events.BANNER_IMPRESSION)
+                }
+
+                override fun onAdLoaded() {
+                    emit(Generated.Events.BANNER_LOAD)
+                }
+
+                override fun onAdOpened() {
+                    emit(Generated.Events.BANNER_OPEN)
+                }
+            }
+        }
+        adView!!.loadAd(ctx!!.optAdRequest())
+        ctx.resolve()
+    }
+
+    override fun show(ctx: Context?) {
+        Objects.requireNonNull(adView)
+        val webView: WebView = ExecuteContext.Companion.plugin!!.getBridge().getWebView()
+        if (getParentView(adView) == null) {
+            addBannerView(ExecuteContext.Companion.plugin, adView)
+        } else if (adView!!.visibility == View.GONE) {
+            adView!!.resume()
+            adView!!.visibility = View.VISIBLE
+        } else {
+            val wvParentView = getParentView(webView)
+            if (parentView !== wvParentView) {
+                parentView!!.removeAllViews()
+                removeFromParentView(parentView)
+                addBannerView(ExecuteContext.Companion.plugin, adView)
+            }
+        }
+        ctx!!.resolve()
+    }
+
+    override fun hide(ctx: Context?) {
+        if (adView != null) {
+            adView!!.pause()
+            adView!!.visibility = View.GONE
+        }
+        ctx!!.resolve()
+    }
+
+    override fun destroy() {
+        if (adView != null) {
+            adView!!.destroy()
+            adView = null
+        }
+        super.destroy()
+    }
+
+    private fun addBannerView(plugin: AdMobPlusPlugin?, adView: AdView?) {
+        val webView = plugin!!.bridge.webView
+        val wvParentView = webView.parent as ViewGroup
+        if (parentView == null) {
+            parentView = LinearLayout(webView.context)
+        }
+        if (wvParentView != null && wvParentView !== parentView) {
+            if (getParentView(parentView) != null) {
+                parentView!!.removeAllViews()
+                removeFromParentView(parentView)
+            }
+            wvParentView.removeView(webView)
+            val content = parentView as LinearLayout?
+            content!!.orientation = LinearLayout.VERTICAL
+            content.setLayoutParams(
+                LinearLayout.LayoutParams(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    0.0f
+                )
+            )
+            webView.layoutParams = LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                1.0f
+            )
+            content.addView(webView)
+            wvParentView.addView(parentView)
+        }
+        if (gravity == Gravity.TOP) {
+            parentView!!.addView(adView, 0)
+        } else {
+            parentView!!.addView(adView)
+        }
+        parentView!!.bringToFront()
+        parentView!!.requestLayout()
+        parentView!!.requestFocus()
+    }
+
+    companion object {
+        @SuppressLint("StaticFieldLeak")
+        private var parentView: ViewGroup? = null
+    }
+}

package/android/src/main/kotlin/admob/plus/capacitor/ads/Interstitial.kt

@@ -0,0 +1,73 @@
+package admob.plus.capacitor.ads
+
+import admob.plus.capacitor.ExecuteContext
+import admob.plus.capacitor.Generated
+import admob.plus.core.Context
+import admob.plus.core.GenericAd
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.FullScreenContentCallback
+import com.google.android.gms.ads.LoadAdError
+import com.google.android.gms.ads.interstitial.InterstitialAd
+import com.google.android.gms.ads.interstitial.InterstitialAdLoadCallback
+
+class Interstitial(ctx: ExecuteContext?) : AdBase(ctx), GenericAd {
+    private var mAd: InterstitialAd? = null
+    override fun destroy() {
+        clear()
+        super.destroy()
+    }
+
+    override fun load(ctx: Context?) {
+        clear()
+        InterstitialAd.load(
+            activity,
+            adUnitId,
+            ctx!!.optAdRequest(),
+            object : InterstitialAdLoadCallback() {
+                override fun onAdLoaded(interstitialAd: InterstitialAd) {
+                    mAd = interstitialAd
+                    mAd!!.fullScreenContentCallback = object : FullScreenContentCallback() {
+                        override fun onAdDismissedFullScreenContent() {
+                            clear()
+                            emit(Generated.Events.INTERSTITIAL_DISMISS)
+                        }
+
+                        override fun onAdFailedToShowFullScreenContent(adError: AdError) {
+                            emit(Generated.Events.INTERSTITIAL_SHOW_FAIL, adError)
+                        }
+
+                        override fun onAdShowedFullScreenContent() {
+                            emit(Generated.Events.INTERSTITIAL_SHOW)
+                        }
+
+                        override fun onAdImpression() {
+                            emit(Generated.Events.INTERSTITIAL_IMPRESSION)
+                        }
+                    }
+                    emit(Generated.Events.INTERSTITIAL_LOAD)
+                    ctx.resolve()
+                }
+
+                override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+                    clear()
+                    emit(Generated.Events.INTERSTITIAL_LOAD_FAIL, loadAdError)
+                    ctx.reject(loadAdError.message)
+                }
+            })
+    }
+
+    override val isLoaded: Boolean
+        get() = mAd != null
+
+    override fun show(ctx: Context?) {
+        mAd!!.show(activity)
+        ctx!!.resolve()
+    }
+
+    private fun clear() {
+        if (mAd != null) {
+            mAd!!.fullScreenContentCallback = null
+            mAd = null
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/capacitor/ads/Rewarded.kt

@@ -0,0 +1,83 @@
+package admob.plus.capacitor.ads
+
+import admob.plus.capacitor.ExecuteContext
+import admob.plus.capacitor.Generated
+import admob.plus.core.Context
+import admob.plus.core.GenericAd
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.FullScreenContentCallback
+import com.google.android.gms.ads.LoadAdError
+import com.google.android.gms.ads.rewarded.RewardItem
+import com.google.android.gms.ads.rewarded.RewardedAd
+import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback
+
+class Rewarded(ctx: ExecuteContext?) : AdBase(ctx), GenericAd {
+    private var mAd: RewardedAd? = null
+    override fun destroy() {
+        clear()
+        super.destroy()
+    }
+
+    override fun load(ctx: Context?) {
+        clear()
+        RewardedAd.load(
+            activity,
+            adUnitId,
+            ctx!!.optAdRequest(),
+            object : RewardedAdLoadCallback() {
+                override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+                    clear()
+                    emit(Generated.Events.REWARDED_LOAD_FAIL, loadAdError)
+                    ctx.reject(loadAdError)
+                }
+
+                override fun onAdLoaded(rewardedAd: RewardedAd) {
+                    mAd = rewardedAd
+                    val ssv = ctx.optServerSideVerificationOptions()
+                    if (ssv != null) {
+                        mAd!!.setServerSideVerificationOptions(ssv)
+                    }
+                    mAd!!.fullScreenContentCallback = object : FullScreenContentCallback() {
+                        override fun onAdDismissedFullScreenContent() {
+                            clear()
+                            emit(Generated.Events.REWARDED_DISMISS)
+                        }
+
+                        override fun onAdFailedToShowFullScreenContent(adError: AdError) {
+                            emit(Generated.Events.REWARDED_SHOW_FAIL, adError)
+                        }
+
+                        override fun onAdShowedFullScreenContent() {
+                            emit(Generated.Events.REWARDED_SHOW)
+                        }
+
+                        override fun onAdImpression() {
+                            emit(Generated.Events.REWARDED_IMPRESSION)
+                        }
+                    }
+                    emit(Generated.Events.REWARDED_LOAD)
+                    ctx.resolve()
+                }
+            })
+    }
+
+    override val isLoaded: Boolean
+        get() = mAd != null
+
+    override fun show(ctx: Context?) {
+        mAd!!.show(activity) { rewardItem: RewardItem? ->
+            emit(
+                Generated.Events.REWARDED_REWARD,
+                rewardItem!!
+            )
+        }
+        ctx!!.resolve()
+    }
+
+    private fun clear() {
+        if (mAd != null) {
+            mAd!!.fullScreenContentCallback = null
+            mAd = null
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/capacitor/ads/RewardedInterstitial.kt

@@ -0,0 +1,83 @@
+package admob.plus.capacitor.ads
+
+import admob.plus.capacitor.ExecuteContext
+import admob.plus.capacitor.Generated
+import admob.plus.core.Context
+import admob.plus.core.GenericAd
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.FullScreenContentCallback
+import com.google.android.gms.ads.LoadAdError
+import com.google.android.gms.ads.rewarded.RewardItem
+import com.google.android.gms.ads.rewardedinterstitial.RewardedInterstitialAd
+import com.google.android.gms.ads.rewardedinterstitial.RewardedInterstitialAdLoadCallback
+
+class RewardedInterstitial(ctx: ExecuteContext?) : AdBase(ctx), GenericAd {
+    private var mAd: RewardedInterstitialAd? = null
+    override fun destroy() {
+        clear()
+        super.destroy()
+    }
+
+    override fun load(ctx: Context?) {
+        clear()
+        RewardedInterstitialAd.load(
+            activity,
+            adUnitId,
+            ctx!!.optAdRequest(),
+            object : RewardedInterstitialAdLoadCallback() {
+                override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+                    clear()
+                    emit(Generated.Events.REWARDED_INTERSTITIAL_LOAD_FAIL, loadAdError)
+                    ctx.reject(loadAdError)
+                }
+
+                override fun onAdLoaded(rewardedAd: RewardedInterstitialAd) {
+                    mAd = rewardedAd
+                    val ssv = ctx.optServerSideVerificationOptions()
+                    if (ssv != null) {
+                        mAd!!.setServerSideVerificationOptions(ssv)
+                    }
+                    mAd!!.fullScreenContentCallback = object : FullScreenContentCallback() {
+                        override fun onAdDismissedFullScreenContent() {
+                            clear()
+                            emit(Generated.Events.REWARDED_INTERSTITIAL_DISMISS)
+                        }
+
+                        override fun onAdFailedToShowFullScreenContent(adError: AdError) {
+                            emit(Generated.Events.REWARDED_INTERSTITIAL_SHOW_FAIL, adError)
+                        }
+
+                        override fun onAdShowedFullScreenContent() {
+                            emit(Generated.Events.REWARDED_INTERSTITIAL_SHOW)
+                        }
+
+                        override fun onAdImpression() {
+                            emit(Generated.Events.REWARDED_INTERSTITIAL_IMPRESSION)
+                        }
+                    }
+                    emit(Generated.Events.REWARDED_INTERSTITIAL_LOAD)
+                    ctx.resolve()
+                }
+            })
+    }
+
+    override val isLoaded: Boolean
+        get() = mAd != null
+
+    override fun show(ctx: Context?) {
+        mAd!!.show(activity) { rewardItem: RewardItem? ->
+            emit(
+                Generated.Events.REWARDED_INTERSTITIAL_REWARD,
+                rewardItem!!
+            )
+        }
+        ctx!!.resolve()
+    }
+
+    private fun clear() {
+        if (mAd != null) {
+            mAd!!.fullScreenContentCallback = null
+            mAd = null
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/core/Ad.kt

@@ -0,0 +1,60 @@
+package admob.plus.core
+
+import android.R
+import android.app.Activity
+import android.view.ViewGroup
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.rewarded.RewardItem
+import java.util.Objects
+
+abstract class Ad(val id: Int, val adUnitId: String) {
+    init {
+        Helper.ads.put(id, this)
+    }
+
+    constructor(ctx: Context) : this(
+        Objects.requireNonNull<Int?>(ctx.optId()),
+        Objects.requireNonNull<String?>(ctx.optAdUnitID())
+    )
+
+    open fun destroy() {
+        Helper.ads.remove(id)
+    }
+
+    protected abstract val adapter: Helper.Adapter
+    val activity: Activity
+        get() = adapter.activity
+    val contentView: ViewGroup?
+        get() = activity.findViewById(R.id.content)
+
+    protected fun emit(eventName: String?, error: AdError) {
+        this.emit(eventName, object : HashMap<String?, Any?>() {
+            init {
+                put("code", error.code)
+                put("message", error.message)
+                put("cause", error.cause)
+            }
+        })
+    }
+
+    protected fun emit(eventName: String?, rewardItem: RewardItem) {
+        this.emit(eventName, object : HashMap<String?, Any?>() {
+            init {
+                put("reward", object : HashMap<String?, Any?>() {
+                    init {
+                        put("amount", rewardItem.amount)
+                        put("type", rewardItem.type)
+                    }
+                })
+            }
+        })
+    }
+
+    protected fun emit(eventName: String?, data: Map<String?, Any?>? = HashMap()) {
+        adapter.emit(eventName, object : HashMap<String?, Any?>(data) {
+            init {
+                put("adId", id)
+            }
+        })
+    }
+}

package/android/src/main/kotlin/admob/plus/core/Context.kt

@@ -0,0 +1,149 @@
+package admob.plus.core
+
+import android.os.Bundle
+import com.google.ads.mediation.admob.AdMobAdapter
+import com.google.android.gms.ads.AdRequest
+import com.google.android.gms.ads.LoadAdError
+import com.google.android.gms.ads.MobileAds
+import com.google.android.gms.ads.RequestConfiguration
+import com.google.android.gms.ads.rewarded.ServerSideVerificationOptions
+import org.json.JSONObject
+import java.util.Objects
+
+interface Context {
+    fun has(name: String): Boolean
+    fun opt(name: String): Any?
+    fun optBoolean(name: String): Boolean?
+    fun optDouble(name: String): Double?
+    fun optDouble(name: String, defaultValue: Double): Double {
+        return optDouble(name) ?: return defaultValue
+    }
+
+    fun optFloat(name: String): Float? {
+        val v = optDouble(name) ?: return null
+        return v.toFloat()
+    }
+
+    fun optInt(name: String): Int?
+    fun optString(name: String): String?
+    fun optStringList(name: String): List<String?>
+    fun optObject(name: String): JSONObject?
+    fun resolve()
+    fun resolve(data: Boolean)
+    fun reject(msg: String?)
+    fun reject() {
+        reject("unknown error")
+    }
+
+    fun reject(loadAdError: LoadAdError) {
+        reject(loadAdError.message)
+    }
+
+    fun optId(): Int? {
+        return optInt("id")
+    }
+
+    fun optAd(): Ad? {
+        return Helper.getAd(optId())
+    }
+
+    fun optAdOrError(): Ad? {
+        val ad = optAd()
+        if (ad == null) {
+            this.reject("Ad not found")
+        }
+        return ad
+    }
+
+    fun optAdUnitID(): String? {
+        return optString("adUnitId")
+    }
+
+    fun optAppMuted(): Boolean? {
+        return optBoolean("appMuted")
+    }
+
+    fun optAppVolume(): Float? {
+        return optFloat("appVolume")
+    }
+
+    fun optPosition(): String? {
+        return optString("position")
+    }
+
+    fun optAdRequest(): AdRequest {
+        val builder = AdRequest.Builder()
+        if (has("contentUrl")) {
+            Objects.requireNonNull(optString("contentUrl"))?.let { builder.setContentUrl(it) }
+        }
+        val extras = Bundle()
+        if (has("npa")) {
+            extras.putString("npa", optString("npa"))
+        }
+        return builder.addNetworkExtrasBundle(AdMobAdapter::class.java, extras).build()
+    }
+
+    fun optRequestConfiguration(): RequestConfiguration {
+        val builder = RequestConfiguration.Builder()
+        if (has("maxAdContentRating")) {
+            builder.setMaxAdContentRating(optString("maxAdContentRating"))
+        }
+        val tagForChildDirectedTreatment = intFromBool(
+            this, "tagForChildDirectedTreatment",
+            RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED,
+            RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE,
+            RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE
+        )
+        if (tagForChildDirectedTreatment != null) {
+            builder.setTagForChildDirectedTreatment(tagForChildDirectedTreatment)
+        }
+        val tagForUnderAgeOfConsent = intFromBool(
+            this, "tagForUnderAgeOfConsent",
+            RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED,
+            RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE,
+            RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE
+        )
+        if (tagForUnderAgeOfConsent != null) {
+            builder.setTagForUnderAgeOfConsent(tagForUnderAgeOfConsent)
+        }
+        if (has("testDeviceIds")) {
+            builder.setTestDeviceIds(optStringList("testDeviceIds"))
+        }
+        return builder.build()
+    }
+
+    fun optServerSideVerificationOptions(): ServerSideVerificationOptions? {
+        val param = "serverSideVerification"
+        val serverSideVerification = optObject(param) ?: return null
+        val builder = ServerSideVerificationOptions.Builder()
+        if (serverSideVerification.has("customData")) {
+            builder.setCustomData(serverSideVerification.optString("customData"))
+        }
+        if (serverSideVerification.has("userId")) {
+            builder.setUserId(serverSideVerification.optString("userId"))
+        }
+        return builder.build()
+    }
+
+    fun configure(helper: Helper) {
+        val appMuted = optAppMuted()
+        if (appMuted != null) {
+            MobileAds.setAppMuted(appMuted)
+        }
+        val appVolume = optAppVolume()
+        if (appVolume != null) {
+            MobileAds.setAppVolume(appVolume)
+        }
+        MobileAds.setRequestConfiguration(optRequestConfiguration())
+        helper.configForTestLab()
+        resolve()
+    }
+
+    companion object {
+        fun intFromBool(ctx: Context, name: String, vNull: Int, vTrue: Int, vFalse: Int): Int? {
+            if (!ctx.has(name)) return null
+            val v = ctx.optBoolean(name) ?: return vNull
+            return if (v) vTrue else vFalse
+        }
+    }
+}

package/android/src/main/kotlin/admob/plus/core/GenericAd.kt

@@ -0,0 +1,21 @@
+package admob.plus.core
+
+interface GenericAd {
+    val isLoaded: Boolean
+        get() {
+            Helper.Companion.NOT_IMPLEMENTED()
+            return false
+        }
+
+    fun load(ctx: Context?) {
+        Helper.Companion.NOT_IMPLEMENTED()
+    }
+
+    fun show(ctx: Context?) {
+        Helper.Companion.NOT_IMPLEMENTED()
+    }
+
+    fun hide(ctx: Context?) {
+        Helper.Companion.NOT_IMPLEMENTED()
+    }
+}