@ququplay/admob 5.3.1

package/android/build.gradle

@@ -0,0 +1,92 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxCoordinatorLayoutVersion = project.hasProperty('androidxCoordinatorLayoutVersion') ? rootProject.ext.androidxCoordinatorLayoutVersion : '1.2.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+    playServicesAdsVersion = project.hasProperty('playServicesAdsVersion') ? rootProject.ext.playServicesAdsVersion : '22.4.0'
+    androidxCoreKTXVersion = project.hasProperty('androidxCoreKTXVersion') ? rootProject.ext.androidxCoreKTXVersion : '1.10.0'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '1.8.20'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.0.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.getcapacitor.community.admob.admob"
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 33
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+        mavenCentral()
+
+}
+
+def testRunner = "1.4.0"
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+
+    testImplementation 'org.mockito:mockito-inline:3.6.28'
+    testImplementation 'org.mockito:mockito-junit-jupiter:2.27.0'
+    testImplementation "org.junit.jupiter:junit-jupiter-api:5.3.2"
+    // https://medium.com/google-developer-experts/pushing-the-limits-of-androidx-test-3776ff249c71
+    testImplementation "androidx.test:core:$testRunner"
+    testImplementation "androidx.test:runner:$testRunner"
+
+    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.3.2"
+    testImplementation "org.junit.jupiter:junit-jupiter-params:5.3.2"
+    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:5.3.2"
+    testImplementation 'org.json:json:20200518'
+    // We do not need expresso tests here... or?
+    //    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    //    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+
+	// after 20.5.0, require minCompileSdk (31)
+    implementation "com.google.android.gms:play-services-ads:$playServicesAdsVersion"
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"
+    implementation "androidx.core:core-ktx:$androidxCoreKTXVersion"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+// Allow to run unit test with  ./gradlew test
+tasks.withType(Test) {
+    useJUnitPlatform()
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+
+  <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+    <uses-permission android:name="android.permission.INTERNET"/>
+  </manifest>

package/android/src/main/java/com/getcapacitor/community/admob/AdMob.java

@@ -0,0 +1,240 @@
+package com.getcapacitor.community.admob;
+
+import android.Manifest;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.community.admob.banner.BannerExecutor;
+import com.getcapacitor.community.admob.consent.AdConsentExecutor;
+import com.getcapacitor.community.admob.helpers.AuthorizationStatusEnum;
+import com.getcapacitor.community.admob.interstitial.AdInterstitialExecutor;
+import com.getcapacitor.community.admob.interstitial.InterstitialAdCallbackAndListeners;
+import com.getcapacitor.community.admob.rewarded.AdRewardExecutor;
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.google.android.gms.ads.initialization.InitializationStatus;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import org.json.JSONException;
+
+@CapacitorPlugin(
+    permissions = { @Permission(alias = "network", strings = { Manifest.permission.ACCESS_NETWORK_STATE, Manifest.permission.INTERNET }) }
+)
+public class AdMob extends Plugin {
+
+    public static final JSArray EMPTY_TESTING_DEVICES = new JSArray();
+
+    private final BannerExecutor bannerExecutor = new BannerExecutor(
+        this::getContext,
+        this::getActivity,
+        this::notifyListeners,
+        getLogTag()
+    );
+    private final AdRewardExecutor adRewardExecutor = new AdRewardExecutor(
+        this::getContext,
+        this::getActivity,
+        this::notifyListeners,
+        getLogTag()
+    );
+    private final AdInterstitialExecutor adInterstitialExecutor = new AdInterstitialExecutor(
+        this::getContext,
+        this::getActivity,
+        this::notifyListeners,
+        getLogTag(),
+        InterstitialAdCallbackAndListeners.INSTANCE
+    );
+
+    private final AdConsentExecutor adConsentExecutor = new AdConsentExecutor(
+        this::getContext,
+        this::getActivity,
+        this::notifyListeners,
+        getLogTag()
+    );
+
+    // Initialize AdMob with appId
+    @PluginMethod
+    public void initialize(final PluginCall call) {
+        this.setRequestConfiguration(call);
+
+        try {
+            MobileAds.initialize(
+                getContext(),
+                new OnInitializationCompleteListener() {
+                    @Override
+                    public void onInitializationComplete(InitializationStatus initializationStatus) {}
+                }
+            );
+            bannerExecutor.initialize();
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage(), ex);
+        }
+    }
+
+    @PluginMethod
+    public void requestTrackingAuthorization(final PluginCall call) {
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void trackingAuthorizationStatus(final PluginCall call) {
+        JSObject response = new JSObject();
+        response.put("status", AuthorizationStatusEnum.AUTHORIZED.getStatus());
+        call.resolve(response);
+    }
+
+    // User Consent
+    @PluginMethod
+    public void requestConsentInfo(final PluginCall call) {
+        adConsentExecutor.requestConsentInfo(call, this::notifyListeners);
+    }
+
+    @PluginMethod
+    public void showConsentForm(final PluginCall call) {
+        adConsentExecutor.showConsentForm(call, this::notifyListeners);
+    }
+
+    @PluginMethod
+    public void resetConsentInfo(final PluginCall call) {
+        adConsentExecutor.resetConsentInfo(call, this::notifyListeners);
+    }
+
+    @PluginMethod
+    public void setApplicationMuted(final PluginCall call) {
+        Boolean muted = call.getBoolean("muted");
+        if (muted == null) {
+            call.reject("muted property cannot be null");
+            return;
+        }
+        MobileAds.setAppMuted(muted);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setApplicationVolume(final PluginCall call) {
+        Float volume = call.getFloat("volume");
+        if (volume == null) {
+            call.reject("volume property cannot be null");
+            return;
+        }
+        MobileAds.setAppVolume(volume);
+        call.resolve();
+    }
+
+    // Show a banner Ad
+    @PluginMethod
+    public void showBanner(final PluginCall call) {
+        bannerExecutor.showBanner(call);
+    }
+
+    // Hide the banner, remove it from screen, but can show it later
+    @PluginMethod
+    public void hideBanner(final PluginCall call) {
+        bannerExecutor.hideBanner(call);
+    }
+
+    // Resume the banner, show it after hide
+    @PluginMethod
+    public void resumeBanner(final PluginCall call) {
+        bannerExecutor.resumeBanner(call);
+    }
+
+    // Destroy the banner, remove it from screen.
+    @PluginMethod
+    public void removeBanner(final PluginCall call) {
+        bannerExecutor.removeBanner(call);
+    }
+
+    @PluginMethod
+    public void prepareInterstitial(final PluginCall call) {
+        adInterstitialExecutor.prepareInterstitial(call, this::notifyListeners);
+    }
+
+    // Show interstitial Ad
+    @PluginMethod
+    public void showInterstitial(final PluginCall call) {
+        adInterstitialExecutor.showInterstitial(call, this::notifyListeners);
+    }
+
+    @PluginMethod
+    public void prepareRewardVideoAd(final PluginCall call) {
+        adRewardExecutor.prepareRewardVideoAd(call, this::notifyListeners);
+    }
+
+    @PluginMethod
+    public void showRewardVideoAd(final PluginCall call) {
+        adRewardExecutor.showRewardVideoAd(call, this::notifyListeners);
+    }
+
+    /**
+     * @see <a href="https://developers.google.com/admob/android/test-ads#enable_test_devices">Test Devices</a>
+     * @see <a href="https://developers.google.com/admob/android/targeting">Target Settings</a>
+     */
+    private void setRequestConfiguration(final PluginCall call) {
+        // Testing Devices
+        final boolean initializeForTesting = call.getBoolean("initializeForTesting", false);
+        final JSArray testingDevices = initializeForTesting
+            ? call.getArray("testingDevices", AdMob.EMPTY_TESTING_DEVICES)
+            : EMPTY_TESTING_DEVICES;
+
+        // tagForChildDirectedTreatment
+        final Boolean tagForChildDirectedTreatment = call.getBoolean("tagForChildDirectedTreatment");
+        int TAG_FOR_CHILD_DIRECTED_TREATMENT;
+
+        if (tagForChildDirectedTreatment == null) {
+            TAG_FOR_CHILD_DIRECTED_TREATMENT = RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED;
+        } else if (tagForChildDirectedTreatment) {
+            TAG_FOR_CHILD_DIRECTED_TREATMENT = RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE;
+        } else {
+            TAG_FOR_CHILD_DIRECTED_TREATMENT = RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE;
+        }
+
+        // tagForUnderAgeOfConsent
+        final Boolean tagForUnderAgeOfConsent = call.getBoolean("tagForUnderAgeOfConsent");
+        int TAG_FOR_UNDER_AGE_OF_CONSENT;
+
+        if (tagForUnderAgeOfConsent == null) {
+            TAG_FOR_UNDER_AGE_OF_CONSENT = RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED;
+        } else if (tagForUnderAgeOfConsent) {
+            TAG_FOR_UNDER_AGE_OF_CONSENT = RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE;
+        } else {
+            TAG_FOR_UNDER_AGE_OF_CONSENT = RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE;
+        }
+
+        // maxAdContentRating
+        final String maxAdContentRating = call.getString("maxAdContentRating");
+        String MAX_AD_CONTENT_RATING = RequestConfiguration.MAX_AD_CONTENT_RATING_UNSPECIFIED;
+
+        if (maxAdContentRating != null) {
+            switch (maxAdContentRating) {
+                case "General":
+                    MAX_AD_CONTENT_RATING = RequestConfiguration.MAX_AD_CONTENT_RATING_G;
+                    break;
+                case "ParentalGuidance":
+                    MAX_AD_CONTENT_RATING = RequestConfiguration.MAX_AD_CONTENT_RATING_PG;
+                    break;
+                case "Teen":
+                    MAX_AD_CONTENT_RATING = RequestConfiguration.MAX_AD_CONTENT_RATING_T;
+                    break;
+                case "MatureAudience":
+                    MAX_AD_CONTENT_RATING = RequestConfiguration.MAX_AD_CONTENT_RATING_MA;
+                    break;
+            }
+        }
+
+        try {
+            RequestConfiguration requestConfiguration = new RequestConfiguration.Builder()
+                .setTestDeviceIds(testingDevices.<String>toList())
+                .setTagForChildDirectedTreatment(TAG_FOR_CHILD_DIRECTED_TREATMENT)
+                .setTagForUnderAgeOfConsent(TAG_FOR_UNDER_AGE_OF_CONSENT)
+                .setMaxAdContentRating(MAX_AD_CONTENT_RATING)
+                .build();
+            MobileAds.setRequestConfiguration(requestConfiguration);
+        } catch (JSONException error) {
+            call.reject(error.toString());
+        }
+    }
+}

package/android/src/main/java/com/getcapacitor/community/admob/banner/BannerAdPluginEvents.kt

@@ -0,0 +1,11 @@
+package com.getcapacitor.community.admob.banner
+
+enum class BannerAdPluginEvents(val webEventName: String) {
+    SizeChanged("bannerAdSizeChanged"),
+    Closed("bannerAdClosed"),
+    FailedToLoad("bannerAdFailedToLoad"),
+    Opened("bannerAdOpened"),
+    Loaded("bannerAdLoaded"),
+    Clicked("bannerAdClicked"),
+    AdImpression("bannerAdImpression"),
+}

package/android/src/main/java/com/getcapacitor/community/admob/banner/BannerAdSizeEnum.kt

@@ -0,0 +1,20 @@
+package com.getcapacitor.community.admob.banner
+
+import com.google.android.gms.ads.AdSize
+
+/**
+ * https://developers.google.com/admob/android/banner#banner_sizes
+ */
+enum class BannerAdSizeEnum(val size: AdSize) {
+    BANNER(AdSize.BANNER),
+    FULL_BANNER(AdSize.FULL_BANNER),
+    LARGE_BANNER(AdSize.LARGE_BANNER),
+    MEDIUM_RECTANGLE(AdSize.MEDIUM_RECTANGLE),
+    LEADERBOARD(AdSize.LEADERBOARD),
+    ADAPTIVE_BANNER(AdSize.INVALID), // We should not use the AdSize here but calculate the device size
+    SMART_BANNER(AdSize.SMART_BANNER);
+
+    override fun toString(): String {
+        return name
+    }
+}

package/android/src/main/java/com/getcapacitor/community/admob/banner/BannerAdSizeInfo.kt

@@ -0,0 +1,17 @@
+package com.getcapacitor.community.admob.banner
+
+import com.getcapacitor.JSObject
+import com.google.android.gms.ads.AdError
+import com.google.android.gms.ads.AdView
+import java.util.*
+
+data class BannerAdSizeInfo(val width: Int, val height: Int) : JSObject() {
+    override fun put(key: String, value: Int): JSObject {
+        throw Exception("Do not put elements directly here use the constructor")
+    }
+    init {
+        super.put("width", width)
+        super.put("height", height)
+    }
+    constructor(mAdView: AdView): this(Objects.requireNonNull(mAdView.adSize)!!.width, Objects.requireNonNull(mAdView.adSize)!!.height)
+}

package/android/src/main/java/com/getcapacitor/community/admob/banner/BannerExecutor.java

@@ -0,0 +1,294 @@
+package com.getcapacitor.community.admob.banner;
+
+import android.app.Activity;
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.RelativeLayout;
+import androidx.annotation.NonNull;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import androidx.core.util.Supplier;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.community.admob.helpers.AdViewIdHelper;
+import com.getcapacitor.community.admob.helpers.RequestHelper;
+import com.getcapacitor.community.admob.models.AdMobPluginError;
+import com.getcapacitor.community.admob.models.AdOptions;
+import com.getcapacitor.community.admob.models.Executor;
+import com.google.android.gms.ads.AdListener;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.AdSize;
+import com.google.android.gms.ads.AdView;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.common.util.BiConsumer;
+
+public class BannerExecutor extends Executor {
+
+    private final JSObject emptyObject = new JSObject();
+    private RelativeLayout mAdViewLayout;
+    private AdView mAdView;
+    private ViewGroup mViewGroup;
+
+    public BannerExecutor(
+        Supplier<Context> contextSupplier,
+        Supplier<Activity> activitySupplier,
+        BiConsumer<String, JSObject> notifyListenersFunction,
+        String pluginLogTag
+    ) {
+        super(contextSupplier, activitySupplier, notifyListenersFunction, pluginLogTag, "BannerExecutor");
+    }
+
+    public void initialize() {
+        mViewGroup = (ViewGroup) ((ViewGroup) activitySupplier.get().findViewById(android.R.id.content)).getChildAt(0);
+    }
+
+    public void showBanner(final PluginCall call) {
+        final AdOptions adOptions = AdOptions.getFactory().createBannerOptions(call);
+        float density = contextSupplier.get().getResources().getDisplayMetrics().density;
+
+        int defaultWidthPixels = contextSupplier.get().getResources().getDisplayMetrics().widthPixels;
+
+        DisplayMetrics metrics = new DisplayMetrics();
+        activitySupplier.get().getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
+        int realWidthPixels = metrics.widthPixels;
+
+        boolean fullscreen = false;
+        if ((activitySupplier.get().getWindow().getAttributes().flags & WindowManager.LayoutParams.FLAG_FULLSCREEN) != 0) {
+            fullscreen = true;
+        }
+
+        if (mAdView != null) {
+            updateExistingAdView(adOptions);
+            return;
+        }
+
+        // Why a try catch block?
+        try {
+            mAdView = new AdView(contextSupplier.get());
+
+            if (!adOptions.adSize.toString().equals("ADAPTIVE_BANNER")) {
+                mAdView.setAdSize(adOptions.adSize.getSize());
+            } else {
+                // ADAPTIVE BANNER
+                mAdView.setAdSize(
+                    AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(contextSupplier.get(), (int) (defaultWidthPixels / density))
+                );
+            }
+
+            // Setup AdView Layout
+            mAdViewLayout = new RelativeLayout(contextSupplier.get());
+            mAdViewLayout.setHorizontalGravity(Gravity.CENTER_HORIZONTAL);
+            mAdViewLayout.setVerticalGravity(Gravity.BOTTOM);
+
+            final CoordinatorLayout.LayoutParams mAdViewLayoutParams = new CoordinatorLayout.LayoutParams(
+                CoordinatorLayout.LayoutParams.WRAP_CONTENT,
+                CoordinatorLayout.LayoutParams.WRAP_CONTENT
+            );
+
+            // TODO: Make an enum like the AdSizeEnum?
+            switch (adOptions.position) {
+                case "TOP_CENTER":
+                    mAdViewLayoutParams.gravity = Gravity.TOP;
+                    break;
+                case "CENTER":
+                    mAdViewLayoutParams.gravity = Gravity.CENTER;
+                    break;
+                default:
+                    mAdViewLayoutParams.gravity = Gravity.BOTTOM;
+                    break;
+            }
+
+            mAdViewLayout.setLayoutParams(mAdViewLayoutParams);
+
+            int densityMargin = (int) (adOptions.margin * density);
+
+            // Center Banner Ads
+            int adWidth = (int) (adOptions.adSize.getSize().getWidth() * density);
+
+            if (adWidth <= 0 || adOptions.adSize.toString().equals("ADAPTIVE_BANNER")) {
+                int margin = 0;
+                if (fullscreen) {
+                    margin = (realWidthPixels - defaultWidthPixels) / 2;
+                }
+                mAdViewLayoutParams.setMargins(margin, densityMargin, margin, densityMargin);
+            } else {
+                int sideMargin = ((int) defaultWidthPixels - adWidth) / 2;
+                if (fullscreen) {
+                    sideMargin = (realWidthPixels - adWidth) / 2;
+                }
+                mAdViewLayoutParams.setMargins(sideMargin, densityMargin, sideMargin, densityMargin);
+            }
+
+            createNewAdView(adOptions);
+
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage(), ex);
+        }
+    }
+
+    public void hideBanner(final PluginCall call) {
+        if (mAdView == null) {
+            call.reject("You tried to hide a banner that was never shown");
+            return;
+        }
+
+        try {
+            activitySupplier
+                .get()
+                .runOnUiThread(
+                    () -> {
+                        if (mAdViewLayout != null) {
+                            mAdViewLayout.setVisibility(View.GONE);
+                            mAdView.pause();
+
+                            final BannerAdSizeInfo sizeInfo = new BannerAdSizeInfo(0, 0);
+
+                            notifyListeners(BannerAdPluginEvents.SizeChanged.getWebEventName(), sizeInfo);
+
+                            call.resolve();
+                        }
+                    }
+                );
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage(), ex);
+        }
+    }
+
+    public void resumeBanner(final PluginCall call) {
+        try {
+            activitySupplier
+                .get()
+                .runOnUiThread(
+                    () -> {
+                        if (mAdViewLayout != null && mAdView != null) {
+                            mAdViewLayout.setVisibility(View.VISIBLE);
+                            mAdView.resume();
+
+                            final BannerAdSizeInfo sizeInfo = new BannerAdSizeInfo(mAdView);
+                            notifyListeners(BannerAdPluginEvents.SizeChanged.getWebEventName(), sizeInfo);
+
+                            Log.d(logTag, "Banner AD Resumed");
+                        }
+                    }
+                );
+
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage(), ex);
+        }
+    }
+
+    public void removeBanner(final PluginCall call) {
+        try {
+            if (mAdView != null) {
+                activitySupplier
+                    .get()
+                    .runOnUiThread(
+                        () -> {
+                            if (mAdView != null) {
+                                mViewGroup.removeView(mAdViewLayout);
+                                mAdViewLayout.removeView(mAdView);
+                                mAdView.destroy();
+                                mAdView = null;
+                                Log.d(logTag, "Banner AD Removed");
+                                final BannerAdSizeInfo sizeInfo = new BannerAdSizeInfo(0, 0);
+                                notifyListeners(BannerAdPluginEvents.SizeChanged.getWebEventName(), sizeInfo);
+                            }
+                        }
+                    );
+            }
+
+            call.resolve();
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage(), ex);
+        }
+    }
+
+    private void updateExistingAdView(AdOptions adOptions) {
+        activitySupplier
+            .get()
+            .runOnUiThread(
+                () -> {
+                    final AdRequest adRequest = RequestHelper.createRequest(adOptions);
+                    mAdView.loadAd(adRequest);
+                }
+            );
+    }
+
+    /**
+     * Follow iOS method Name:
+     * https://developers.google.com/admob/ios/banner?hl=ja
+     */
+    private void createNewAdView(AdOptions adOptions) {
+        // Run AdMob In Main UI Thread
+        activitySupplier
+            .get()
+            .runOnUiThread(
+                () -> {
+                    final AdRequest adRequest = RequestHelper.createRequest(adOptions);
+                    // Assign the correct id needed
+                    AdViewIdHelper.assignIdToAdView(mAdView, adOptions, adRequest, logTag, contextSupplier.get());
+                    // Add the AdView to the view hierarchy.
+                    mAdViewLayout.addView(mAdView);
+                    // Start loading the ad.
+                    mAdView.loadAd(adRequest);
+                    mAdView.setAdListener(
+                        new AdListener() {
+                            @Override
+                            public void onAdLoaded() {
+                                final BannerAdSizeInfo sizeInfo = new BannerAdSizeInfo(mAdView);
+
+                                notifyListeners(BannerAdPluginEvents.SizeChanged.getWebEventName(), sizeInfo);
+                                notifyListeners(BannerAdPluginEvents.Loaded.getWebEventName(), emptyObject);
+                                super.onAdLoaded();
+                            }
+
+                            @Override
+                            public void onAdFailedToLoad(@NonNull LoadAdError adError) {
+                                if (mAdView != null) {
+                                    mViewGroup.removeView(mAdViewLayout);
+                                    mAdViewLayout.removeView(mAdView);
+                                    mAdView.destroy();
+                                    mAdView = null;
+                                }
+
+                                final BannerAdSizeInfo sizeInfo = new BannerAdSizeInfo(0, 0);
+                                notifyListeners(BannerAdPluginEvents.SizeChanged.getWebEventName(), sizeInfo);
+
+                                final AdMobPluginError adMobPluginError = new AdMobPluginError(adError);
+                                notifyListeners(BannerAdPluginEvents.FailedToLoad.getWebEventName(), adMobPluginError);
+
+                                super.onAdFailedToLoad(adError);
+                            }
+
+                            @Override
+                            public void onAdOpened() {
+                                notifyListeners(BannerAdPluginEvents.Opened.getWebEventName(), emptyObject);
+                                super.onAdOpened();
+                            }
+
+                            @Override
+                            public void onAdClosed() {
+                                notifyListeners(BannerAdPluginEvents.Closed.getWebEventName(), emptyObject);
+                                super.onAdClosed();
+                            }
+
+                            @Override
+                            public void onAdImpression() {
+                                notifyListeners(BannerAdPluginEvents.AdImpression.getWebEventName(), emptyObject);
+                                super.onAdImpression();
+                            }
+                        }
+                    );
+
+                    // Add AdViewLayout top of the WebView
+                    mViewGroup.addView(mAdViewLayout);
+                }
+            );
+    }
+}