@capgo/capacitor-admob 7.0.0

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

@@ -0,0 +1,119 @@
+package admob.plus.core
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.res.Resources
+import android.provider.Settings
+import android.util.DisplayMetrics
+import android.util.SparseArray
+import android.view.View
+import android.view.ViewGroup
+import com.google.android.gms.ads.MobileAds
+import org.json.JSONArray
+import java.math.BigInteger
+import java.security.MessageDigest
+import java.security.NoSuchAlgorithmException
+import java.util.Locale
+
+class Helper(private val adapter: Adapter) {
+    val activity: Activity
+        get() = adapter.activity
+    val isRunningInTestLab: Boolean
+        get() {
+            val testLabSetting =
+                Settings.System.getString(activity.contentResolver, "firebase.test.lab")
+            return "true" == testLabSetting
+        }
+
+    fun configForTestLab() {
+        if (!isRunningInTestLab) {
+            return
+        }
+        val config = MobileAds.getRequestConfiguration()
+        val testDeviceIds = config.testDeviceIds
+        val deviceId = deviceId
+        if (testDeviceIds.contains(deviceId)) {
+            return
+        }
+        testDeviceIds.add(deviceId)
+        val builder = config.toBuilder()
+        builder.setTestDeviceIds(testDeviceIds)
+        MobileAds.setRequestConfiguration(builder.build())
+    }
+
+    private val deviceId: String
+        private get() {
+            // This will request test ads on the emulator and device by passing this hashed device ID.
+            @SuppressLint("HardwareIds") val ANDROID_ID = Settings.Secure.getString(
+                activity.contentResolver, Settings.Secure.ANDROID_ID
+            )
+            return md5(ANDROID_ID).uppercase(Locale.getDefault())
+        }
+
+    interface Adapter {
+        val activity: Activity
+        fun emit(eventName: String?, data: Map<String?, Any?>?)
+        fun emit(eventName: String?) {
+            emit(eventName, HashMap())
+        }
+    }
+
+    companion object {
+        val ads = SparseArray<Ad>()
+        fun getAd(id: Int?): Ad {
+            return ads[id!!]
+        }
+
+        fun dpToPx(dp: Double): Double {
+            return dp * Resources.getSystem().displayMetrics.density
+        }
+
+        fun pxToDp(px: Int): Int {
+            val displayMetrics =
+                Resources.getSystem().displayMetrics
+            return Math.round(px / (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT))
+        }
+
+        @JvmStatic
+        fun jsonArray2stringList(a: JSONArray?): List<String> {
+            val result: MutableList<String> = ArrayList()
+            if (a == null) {
+                return result
+            }
+            for (i in 0 until a.length()) {
+                val testDeviceId = a.optString(i)
+                if (testDeviceId != null) {
+                    result.add(testDeviceId)
+                }
+            }
+            return result
+        }
+
+        @JvmStatic
+        fun getParentView(view: View?): ViewGroup? {
+            return if (view == null) null else view.parent as ViewGroup
+        }
+
+        @JvmStatic
+        fun removeFromParentView(view: View?): ViewGroup? {
+            val viewParent = getParentView(view)
+            viewParent?.removeView(view)
+            return viewParent
+        }
+
+        fun NOT_IMPLEMENTED() {
+            throw UnsupportedOperationException("Not implemented.")
+        }
+
+        private fun md5(s: String): String {
+            try {
+                val digest = MessageDigest.getInstance("MD5")
+                digest.update(s.toByteArray())
+                val bigInt = BigInteger(1, digest.digest())
+                return String.format("%32s", bigInt.toString(16)).replace(' ', '0')
+            } catch (ignore: NoSuchAlgorithmException) {
+            }
+            return ""
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,311 @@
+{
+  "api": {
+    "name": "AdMobPlusPlugin",
+    "slug": "admobplusplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "start",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "start"
+      },
+      {
+        "name": "configure",
+        "signature": "(config: AdMobConfig) => Promise<void>",
+        "parameters": [
+          {
+            "name": "config",
+            "docs": "",
+            "type": "AdMobConfig"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "AdMobConfig"
+        ],
+        "slug": "configure"
+      },
+      {
+        "name": "configRequest",
+        "signature": "(requestConfig: RequestConfig) => Promise<void>",
+        "parameters": [
+          {
+            "name": "requestConfig",
+            "docs": "",
+            "type": "RequestConfig"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "RequestConfig"
+        ],
+        "slug": "configrequest"
+      },
+      {
+        "name": "adCreate",
+        "signature": "<O extends MobileAdOptions>(opts: O) => Promise<void>",
+        "parameters": [
+          {
+            "name": "opts",
+            "docs": "",
+            "type": "O"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "MobileAdOptions",
+          "O"
+        ],
+        "slug": "adcreate"
+      },
+      {
+        "name": "adIsLoaded",
+        "signature": "(opts: { id: number; }) => Promise<boolean>",
+        "parameters": [
+          {
+            "name": "opts",
+            "docs": "",
+            "type": "{ id: number; }"
+          }
+        ],
+        "returns": "Promise<boolean>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "adisloaded"
+      },
+      {
+        "name": "adLoad",
+        "signature": "(opts: { id: number; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "opts",
+            "docs": "",
+            "type": "{ id: number; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "adload"
+      },
+      {
+        "name": "adShow",
+        "signature": "(opts: { id: number; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "opts",
+            "docs": "",
+            "type": "{ id: number; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "adshow"
+      },
+      {
+        "name": "adHide",
+        "signature": "(opts: { id: number; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "opts",
+            "docs": "",
+            "type": "{ id: number; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "adhide"
+      },
+      {
+        "name": "trackingAuthorizationStatus",
+        "signature": "() => Promise<{ status: TrackingAuthorizationStatus | false; }>",
+        "parameters": [],
+        "returns": "Promise<{ status: false | TrackingAuthorizationStatus; }>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "TrackingAuthorizationStatus"
+        ],
+        "slug": "trackingauthorizationstatus"
+      },
+      {
+        "name": "requestTrackingAuthorization",
+        "signature": "() => Promise<{ status: TrackingAuthorizationStatus | false; }>",
+        "parameters": [],
+        "returns": "Promise<{ status: false | TrackingAuthorizationStatus; }>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "TrackingAuthorizationStatus"
+        ],
+        "slug": "requesttrackingauthorization"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: string, listenerFunc: (event: any) => void) => Promise<PluginListenerHandle> & PluginListenerHandle",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "",
+            "type": "string"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "",
+            "type": "(event: any) => void"
+          }
+        ],
+        "returns": "Promise<PluginListenerHandle> & PluginListenerHandle",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "PluginListenerHandle"
+        ],
+        "slug": "addlistenerstring-"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "PluginListenerHandle",
+      "slug": "pluginlistenerhandle",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "remove",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "() => Promise<void>"
+        }
+      ]
+    }
+  ],
+  "enums": [
+    {
+      "name": "MaxAdContentRating",
+      "slug": "maxadcontentrating",
+      "members": [
+        {
+          "name": "G",
+          "value": "'G'",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "MA",
+          "value": "'MA'",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "PG",
+          "value": "'PG'",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "T",
+          "value": "'T'",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "UNSPECIFIED",
+          "value": "''",
+          "tags": [],
+          "docs": ""
+        }
+      ]
+    },
+    {
+      "name": "TrackingAuthorizationStatus",
+      "slug": "trackingauthorizationstatus",
+      "members": [
+        {
+          "name": "notDetermined",
+          "value": "0",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "restricted",
+          "value": "1",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "denied",
+          "value": "2",
+          "tags": [],
+          "docs": ""
+        },
+        {
+          "name": "authorized",
+          "value": "3",
+          "tags": [],
+          "docs": ""
+        }
+      ]
+    }
+  ],
+  "typeAliases": [
+    {
+      "name": "AdMobConfig",
+      "slug": "admobconfig",
+      "docs": "",
+      "types": [
+        {
+          "text": "{\n  appMuted?: boolean;\n  appVolume?: number;\n}",
+          "complexTypes": []
+        }
+      ]
+    },
+    {
+      "name": "RequestConfig",
+      "slug": "requestconfig",
+      "docs": "",
+      "types": [
+        {
+          "text": "{\n  maxAdContentRating?: MaxAdContentRating;\n  sameAppKey?: boolean;\n  tagForChildDirectedTreatment?: boolean | null;\n  tagForUnderAgeOfConsent?: boolean | null;\n  testDeviceIds?: string[];\n}",
+          "complexTypes": [
+            "MaxAdContentRating"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "MobileAdOptions",
+      "slug": "mobileadoptions",
+      "docs": "",
+      "types": [
+        {
+          "text": "{ adUnitId: string }",
+          "complexTypes": []
+        }
+      ]
+    }
+  ],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,53 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+export declare enum MaxAdContentRating {
+    G = "G",
+    MA = "MA",
+    PG = "PG",
+    T = "T",
+    UNSPECIFIED = ""
+}
+export type AdMobConfig = {
+    appMuted?: boolean;
+    appVolume?: number;
+};
+export type RequestConfig = {
+    maxAdContentRating?: MaxAdContentRating;
+    sameAppKey?: boolean;
+    tagForChildDirectedTreatment?: boolean | null;
+    tagForUnderAgeOfConsent?: boolean | null;
+    testDeviceIds?: string[];
+};
+export declare enum TrackingAuthorizationStatus {
+    notDetermined = 0,
+    restricted = 1,
+    denied = 2,
+    authorized = 3
+}
+export type MobileAdOptions = {
+    adUnitId: string;
+};
+export interface AdMobPlusPlugin {
+    start(): Promise<void>;
+    configure(config: AdMobConfig): Promise<void>;
+    configRequest(requestConfig: RequestConfig): Promise<void>;
+    adCreate<O extends MobileAdOptions>(opts: O): Promise<void>;
+    adIsLoaded(opts: {
+        id: number;
+    }): Promise<boolean>;
+    adLoad(opts: {
+        id: number;
+    }): Promise<void>;
+    adShow(opts: {
+        id: number;
+    }): Promise<void>;
+    adHide(opts: {
+        id: number;
+    }): Promise<void>;
+    trackingAuthorizationStatus(): Promise<{
+        status: TrackingAuthorizationStatus | false;
+    }>;
+    requestTrackingAuthorization(): Promise<{
+        status: TrackingAuthorizationStatus | false;
+    }>;
+    addListener(eventName: string, listenerFunc: (event: any) => void): Promise<PluginListenerHandle> & PluginListenerHandle;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,16 @@
+export var MaxAdContentRating;
+(function (MaxAdContentRating) {
+    MaxAdContentRating["G"] = "G";
+    MaxAdContentRating["MA"] = "MA";
+    MaxAdContentRating["PG"] = "PG";
+    MaxAdContentRating["T"] = "T";
+    MaxAdContentRating["UNSPECIFIED"] = "";
+})(MaxAdContentRating || (MaxAdContentRating = {}));
+export var TrackingAuthorizationStatus;
+(function (TrackingAuthorizationStatus) {
+    TrackingAuthorizationStatus[TrackingAuthorizationStatus["notDetermined"] = 0] = "notDetermined";
+    TrackingAuthorizationStatus[TrackingAuthorizationStatus["restricted"] = 1] = "restricted";
+    TrackingAuthorizationStatus[TrackingAuthorizationStatus["denied"] = 2] = "denied";
+    TrackingAuthorizationStatus[TrackingAuthorizationStatus["authorized"] = 3] = "authorized";
+})(TrackingAuthorizationStatus || (TrackingAuthorizationStatus = {}));
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAEA,MAAM,CAAN,IAAY,kBAMX;AAND,WAAY,kBAAkB;IAC5B,6BAAO,CAAA;IACP,+BAAS,CAAA;IACT,+BAAS,CAAA;IACT,6BAAO,CAAA;IACP,sCAAgB,CAAA;AAClB,CAAC,EANW,kBAAkB,KAAlB,kBAAkB,QAM7B;AAeD,MAAM,CAAN,IAAY,2BAKX;AALD,WAAY,2BAA2B;IACrC,+FAAiB,CAAA;IACjB,yFAAc,CAAA;IACd,iFAAU,CAAA;IACV,yFAAc,CAAA;AAChB,CAAC,EALW,2BAA2B,KAA3B,2BAA2B,QAKtC"}

package/dist/esm/index.d.ts

@@ -0,0 +1,50 @@
+import type { AdMobPlusPlugin, MobileAdOptions } from './definitions';
+declare const AdMob: AdMobPlusPlugin;
+declare class MobileAd<T extends MobileAdOptions = MobileAdOptions> {
+    #private;
+    private static allAds;
+    private static idCounter;
+    readonly id: number;
+    protected readonly opts: T;
+    constructor(opts: T);
+    private static nextId;
+    get adUnitId(): string;
+    protected isLoaded(): Promise<boolean>;
+    protected load(): Promise<void>;
+    protected show(): Promise<void>;
+    protected hide(): Promise<void>;
+    protected init(): Promise<void>;
+}
+type Position = 'top' | 'bottom';
+export interface BannerAdOptions extends MobileAdOptions {
+    position?: Position;
+}
+declare class BannerAd extends MobileAd {
+    #private;
+    static cls: string;
+    constructor(opts: BannerAdOptions);
+    isLoaded(): Promise<boolean>;
+    load(): Promise<void>;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+}
+declare class InterstitialAd extends MobileAd {
+    static cls: string;
+    isLoaded(): Promise<boolean>;
+    load(): Promise<void>;
+    show(): Promise<void>;
+}
+declare class RewardedAd extends MobileAd {
+    static cls: string;
+    isLoaded(): Promise<boolean>;
+    load(): Promise<void>;
+    show(): Promise<void>;
+}
+declare class RewardedInterstitialAd extends MobileAd {
+    static cls: string;
+    isLoaded(): Promise<boolean>;
+    load(): Promise<void>;
+    show(): Promise<void>;
+}
+export * from './definitions';
+export { AdMob, BannerAd, InterstitialAd, RewardedAd, RewardedInterstitialAd };

package/dist/esm/index.js

@@ -0,0 +1,138 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _MobileAd_created, _MobileAd_init, _BannerAd_loaded;
+import { registerPlugin } from '@capacitor/core';
+const AdMob = registerPlugin('AdMobPlus', {
+    web: () => import('./web').then((m) => new m.AdMobPlusWeb()),
+});
+let started = false;
+let startPromise = null;
+const start = AdMob.start;
+AdMob.start = async () => {
+    startPromise = start();
+    const result = await startPromise;
+    started = true;
+    return result;
+};
+class MobileAd {
+    constructor(opts) {
+        _MobileAd_created.set(this, false);
+        _MobileAd_init.set(this, null);
+        this.opts = opts;
+        this.id = MobileAd.nextId();
+        MobileAd.allAds[this.id] = this;
+    }
+    static nextId() {
+        MobileAd.idCounter += 1;
+        return MobileAd.idCounter;
+    }
+    get adUnitId() {
+        return this.opts.adUnitId;
+    }
+    async isLoaded() {
+        await this.init();
+        return AdMob.adIsLoaded({ id: this.id });
+    }
+    async load() {
+        await this.init();
+        return AdMob.adLoad(Object.assign(Object.assign({}, this.opts), { id: this.id }));
+    }
+    async show() {
+        await this.init();
+        return AdMob.adShow({ id: this.id });
+    }
+    async hide() {
+        await this.init();
+        return AdMob.adHide({ id: this.id });
+    }
+    async init() {
+        var _a;
+        if (__classPrivateFieldGet(this, _MobileAd_created, "f"))
+            return;
+        if (!started) {
+            if (startPromise === null)
+                start();
+            await startPromise;
+        }
+        if (__classPrivateFieldGet(this, _MobileAd_init, "f") === null) {
+            const cls = (_a = this.constructor.cls) !== null && _a !== void 0 ? _a : this.constructor.name;
+            __classPrivateFieldSet(this, _MobileAd_init, AdMob.adCreate(Object.assign(Object.assign({}, this.opts), { id: this.id, cls })), "f");
+        }
+        await __classPrivateFieldGet(this, _MobileAd_init, "f");
+        __classPrivateFieldSet(this, _MobileAd_created, true, "f");
+    }
+}
+_MobileAd_created = new WeakMap(), _MobileAd_init = new WeakMap();
+MobileAd.allAds = {};
+MobileAd.idCounter = 0;
+class BannerAd extends MobileAd {
+    constructor(opts) {
+        super(Object.assign({ position: 'bottom' }, opts));
+        _BannerAd_loaded.set(this, false);
+    }
+    isLoaded() {
+        return super.isLoaded();
+    }
+    async load() {
+        await super.load();
+        __classPrivateFieldSet(this, _BannerAd_loaded, true, "f");
+    }
+    async show() {
+        if (!__classPrivateFieldGet(this, _BannerAd_loaded, "f"))
+            await this.load();
+        await super.show();
+    }
+    hide() {
+        return super.hide();
+    }
+}
+_BannerAd_loaded = new WeakMap();
+BannerAd.cls = 'BannerAd';
+class InterstitialAd extends MobileAd {
+    isLoaded() {
+        return super.isLoaded();
+    }
+    async load() {
+        return super.load();
+    }
+    async show() {
+        return super.show();
+    }
+}
+InterstitialAd.cls = 'InterstitialAd';
+class RewardedAd extends MobileAd {
+    isLoaded() {
+        return super.isLoaded();
+    }
+    async load() {
+        return super.load();
+    }
+    async show() {
+        return super.show();
+    }
+}
+RewardedAd.cls = 'RewardedAd';
+class RewardedInterstitialAd extends MobileAd {
+    isLoaded() {
+        return super.isLoaded();
+    }
+    async load() {
+        return super.load();
+    }
+    async show() {
+        return super.show();
+    }
+}
+RewardedInterstitialAd.cls = 'RewardedInterstitialAd';
+export * from './definitions';
+export { AdMob, BannerAd, InterstitialAd, RewardedAd, RewardedInterstitialAd };
+//# sourceMappingURL=index.js.map