cordova-plugin-admob-nextgen 1.0.0

package/src/android/AdMobNextGen.java

@@ -0,0 +1,306 @@
+package com.emi.cordova.admob.nextgen;
+
+import android.app.Activity;
+import android.app.Application; 
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Build; 
+import android.os.Bundle;
+import android.util.Log;
+import android.view.WindowInsets; 
+import android.view.WindowInsetsController; 
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.google.android.libraries.ads.mobile.sdk.MobileAds;
+import com.google.android.libraries.ads.mobile.sdk.common.RequestConfiguration;
+import com.google.android.libraries.ads.mobile.sdk.initialization.InitializationConfig;
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class AdMobNextGen extends CordovaPlugin {
+
+    private static final String TAG = "AdMobNextGen";
+    private BannerExecutor bannerExecutor;
+    private AppOpenAdExecutor appOpenAdExecutor;
+    private InterstitialExecutor interstitialExecutor;
+    private RewardedExecutor rewardedExecutor;
+    private RewardedInterstitialExecutor rewardedInterstitialExecutor;
+    private ConsentExecutor consentExecutor;
+    private GlobalSettingsExecutor globalSettingsExecutor;
+    private NativeExecutor nativeExecutor;
+
+    private BannerPreloadExecutor bannerPreloadExecutor;
+
+    @Override
+    public void pluginInitialize() {
+        super.pluginInitialize();
+
+        applyAdMobAPI35WorkaroundIfNeeded(cordova.getActivity().getApplication());
+
+        bannerExecutor = new BannerExecutor(cordova, webView);
+        interstitialExecutor = new InterstitialExecutor(cordova, webView);
+        rewardedExecutor = new RewardedExecutor(cordova, webView);
+        rewardedInterstitialExecutor = new RewardedInterstitialExecutor(cordova, webView);
+        consentExecutor = new ConsentExecutor(cordova, webView);
+        globalSettingsExecutor = new GlobalSettingsExecutor(cordova);
+
+        appOpenAdExecutor = AppOpenAdExecutor.getInstance();
+        appOpenAdExecutor.initialize(cordova, webView);
+        nativeExecutor = new NativeExecutor(cordova, webView);
+
+        bannerPreloadExecutor = new BannerPreloadExecutor(cordova, webView);
+    }
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+
+        if ("setAppVolume".equals(action)) {
+            globalSettingsExecutor.setAppVolume(args, callbackContext);
+            return true;
+        }
+        if ("setAppMuted".equals(action)) {
+            globalSettingsExecutor.setAppMuted(args, callbackContext);
+            return true;
+        }
+        if ("setRequestConfiguration".equals(action)) {
+            globalSettingsExecutor.setRequestConfiguration(args, callbackContext);
+            return true;
+        }
+
+        if ("requestConsentInfo".equals(action)) {
+            consentExecutor.requestConsentInfo(args, callbackContext);
+            return true;
+        }
+        if ("showPrivacyOptionsForm".equals(action)) {
+            consentExecutor.showPrivacyOptionsForm(callbackContext);
+            return true;
+        }
+        if ("canRequestAds".equals(action)) {
+            consentExecutor.canRequestAds(callbackContext);
+            return true;
+        }
+        if ("getTCData".equals(action)) {
+            consentExecutor.getTCData(callbackContext);
+            return true;
+        }
+
+        if ("initialize".equals(action)) {
+            this.initializeSDK(args, callbackContext);
+            return true;
+        }
+
+        if ("createBanner".equals(action)) {
+            bannerExecutor.createBanner(args, callbackContext);
+            return true;
+        }
+        if ("hideBanner".equals(action)) {
+            bannerExecutor.hideBanner(callbackContext);
+            return true;
+        }
+        if ("showBanner".equals(action)) {
+            bannerExecutor.showBanner(callbackContext);
+            return true;
+        }
+
+        if ("startBannerPreload".equals(action)) {
+            bannerPreloadExecutor.startPreload(args, callbackContext);
+            return true;
+        }
+        if ("showPreloadedBanner".equals(action)) {
+            bannerPreloadExecutor.showPolledAd(args, callbackContext);
+            return true;
+        }
+        if ("stopBannerPreload".equals(action)) {
+            bannerPreloadExecutor.stopPreloadAndClear();
+            callbackContext.success();
+            return true;
+        }
+
+        if ("removeBanner".equals(action)) {
+            bannerExecutor.destroy();
+            callbackContext.success();
+            return true;
+        }
+
+        if ("loadAppOpenAd".equals(action)) {
+            if (appOpenAdExecutor != null) {
+                appOpenAdExecutor.loadAd(args, callbackContext);
+            }
+            return true;
+        }
+
+        if ("showAppOpenAd".equals(action)) {
+            if (appOpenAdExecutor != null) {
+                appOpenAdExecutor.showAdIfAvailable(cordova.getActivity());
+            }
+            callbackContext.success();
+            return true;
+        }
+
+        if ("setAppOpenAutoShow".equals(action)) {
+            boolean shouldShow = args.getBoolean(0);
+            if (appOpenAdExecutor != null) {
+                appOpenAdExecutor.setAutoShow(shouldShow);
+            }
+            callbackContext.success();
+            return true;
+        }
+
+        if ("createNativeAd".equals(action)) {
+            nativeExecutor.createNativeAd(args, callbackContext);
+            return true;
+        }
+        if ("removeNativeAd".equals(action)) {
+            nativeExecutor.removeNativeAd();
+            callbackContext.success();
+            return true;
+        }
+
+        if ("createInterstitial".equals(action)) {
+            interstitialExecutor.createInterstitial(args, callbackContext);
+            return true;
+        }
+        if ("showInterstitial".equals(action)) {
+            interstitialExecutor.showInterstitial(callbackContext);
+            return true;
+        }
+
+        if ("createRewarded".equals(action)) {
+            rewardedExecutor.createRewarded(args, callbackContext);
+            return true;
+        }
+        if ("showRewarded".equals(action)) {
+            rewardedExecutor.showRewarded(callbackContext);
+            return true;
+        }
+
+        if ("createRewardedInterstitial".equals(action)) {
+            rewardedInterstitialExecutor.createRewardedInterstitial(args, callbackContext);
+            return true;
+        }
+        if ("showRewardedInterstitial".equals(action)) {
+            rewardedInterstitialExecutor.showRewardedInterstitial(callbackContext);
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onResume(boolean multitasking) {
+        super.onResume(multitasking);
+        if (appOpenAdExecutor != null && appOpenAdExecutor.shouldAutoShow()) {
+            appOpenAdExecutor.showAdIfAvailable(cordova.getActivity());
+        }
+    }
+
+    private void initializeSDK(JSONArray args, CallbackContext callbackContext) {
+        String appId = getAppIdFromManifest();
+        if (appId == null) {
+            callbackContext.error("AdMob App ID missing");
+            return;
+        }
+
+        cordova.getThreadPool().execute(() -> {
+            try {
+                InitializationConfig.Builder initConfigBuilder = new InitializationConfig.Builder(appId);
+
+                JSONObject configJson = args.optJSONObject(0);
+
+                if (configJson != null) {
+
+                    RequestConfiguration requestConfig = GlobalSettingsExecutor.buildRequestConfiguration(configJson);
+                    initConfigBuilder.setRequestConfiguration(requestConfig);
+                }
+
+                InitializationConfig config = initConfigBuilder.build();
+
+                MobileAds.initialize(
+                        cordova.getActivity(),
+                        config,
+                        initializationStatus -> {
+                            cordova.getActivity().runOnUiThread(() -> callbackContext.success("Initialized"));
+                        }
+                );
+            } catch (Exception e) {
+                cordova.getActivity().runOnUiThread(() -> callbackContext.error(e.getMessage()));
+            }
+        });
+    }
+
+    private String getAppIdFromManifest() {
+        try {
+            Context context = cordova.getActivity().getApplicationContext();
+            ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
+                    context.getPackageName(), PackageManager.GET_META_DATA);
+            Bundle bundle = ai.metaData;
+            return bundle.getString("com.google.android.gms.ads.APPLICATION_ID");
+        } catch (Exception e) { return null; }
+    }
+
+    @Override
+    public void onDestroy() {
+        if (bannerExecutor != null) bannerExecutor.destroy();
+        super.onDestroy();
+    }
+
+    public static void applyAdMobAPI35WorkaroundIfNeeded(Application application) {
+
+        if (Build.VERSION.SDK_INT < 35) {
+            return;
+        }
+
+        application.registerActivityLifecycleCallbacks(new Application.ActivityLifecycleCallbacks() {
+            @Override
+            public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {}
+
+            @Override
+            public void onActivityStarted(@NonNull Activity activity) {
+                applyAPI35WorkaroundToActivity(activity);
+            }
+
+            @Override
+            public void onActivityResumed(@NonNull Activity activity) {
+                applyAPI35WorkaroundToActivity(activity);
+            }
+
+            @Override
+            public void onActivityPaused(@NonNull Activity activity) {}
+
+            @Override
+            public void onActivityStopped(@NonNull Activity activity) {}
+
+            @Override
+            public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {}
+
+            @Override
+            public void onActivityDestroyed(@NonNull Activity activity) {}
+        });
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.S)
+    private static void applyAPI35WorkaroundToActivity(Activity activity) {
+
+        if (!"com.google.android.gms.ads.AdActivity".equals(activity.getClass().getName())) {
+            return;
+        }
+
+        if (Build.VERSION.SDK_INT >= 30) {
+            WindowInsetsController c = activity.getWindow().getInsetsController();
+            if (c != null) {
+
+                c.hide(WindowInsets.Type.systemBars());
+                c.setSystemBarsBehavior(WindowInsetsController.BEHAVIOR_DEFAULT);
+            }
+        }
+    }
+}

package/src/android/AppOpenAdExecutor.java

@@ -0,0 +1,246 @@
+package com.emi.cordova.admob.nextgen;
+
+import android.app.Activity;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaWebView;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Date;
+
+import com.google.android.libraries.ads.mobile.sdk.appopen.AppOpenAd;
+import com.google.android.libraries.ads.mobile.sdk.appopen.AppOpenAdEventCallback;
+import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback;
+import com.google.android.libraries.ads.mobile.sdk.common.AdRequest;
+import com.google.android.libraries.ads.mobile.sdk.common.AdValue;
+import com.google.android.libraries.ads.mobile.sdk.common.FullScreenContentError;
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError;
+
+public class AppOpenAdExecutor {
+
+    private static final String TAG = "AdMobAppOpen";
+    private static AppOpenAdExecutor instance;
+
+    private CordovaInterface cordova;
+    private CordovaWebView webView;
+
+    private AppOpenAd appOpenAd;
+
+    private boolean isLoadingAd = false;
+    private boolean isShowingAd = false;
+    private long loadTime = 0;
+
+    private boolean isAutoShow = false;
+    private String currentAdUnitId = null;
+
+    private long lastLoadTime = 0;
+    private long minLoadInterval = 5000;
+
+    public static synchronized AppOpenAdExecutor getInstance() {
+        if (instance == null) {
+            instance = new AppOpenAdExecutor();
+        }
+        return instance;
+    }
+
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        this.cordova = cordova;
+        this.webView = webView;
+    }
+
+    public void loadAd(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject options = args.optJSONObject(0);
+            String adUnitId;
+
+            if (options != null) {
+                adUnitId = options.getString("adUnitId");
+                if (options.has("isAutoShow")) this.isAutoShow = options.getBoolean("isAutoShow");
+                if (options.has("retryInterval")) this.minLoadInterval = options.getLong("retryInterval");
+            } else {
+                adUnitId = args.getString(0);
+                this.isAutoShow = false;
+            }
+
+            this.currentAdUnitId = adUnitId;
+            loadAdInternal(adUnitId, callbackContext);
+
+        } catch (JSONException e) {
+            if (callbackContext != null) callbackContext.error("Invalid Args: " + e.getMessage());
+        }
+    }
+
+    private void loadAdInternal(String adUnitId, CallbackContext callbackContext) {
+        long currentTime = new Date().getTime();
+
+        if (isLoadingAd || isAdAvailable()) {
+            if (isAdAvailable()) {
+                fireEvent("on.appopen.loaded", null);
+                if (callbackContext != null) callbackContext.success("Ad Ready");
+            }
+            return;
+        }
+
+        if ((currentTime - lastLoadTime) < minLoadInterval) {
+            return;
+        }
+
+        isLoadingAd = true;
+        lastLoadTime = currentTime;
+
+        if (callbackContext != null) {
+            PluginResult r = new PluginResult(PluginResult.Status.OK, "Loading started...");
+            r.setKeepCallback(true);
+            callbackContext.sendPluginResult(r);
+        }
+
+        cordova.getActivity().runOnUiThread(() -> {
+
+            AdRequest request = new AdRequest.Builder(adUnitId).build();
+
+            AppOpenAd.load(
+                    request,
+                    new AdLoadCallback<AppOpenAd>() {
+                        @Override
+                        public void onAdLoaded(@NonNull AppOpenAd ad) {
+                            isLoadingAd = false;
+                            appOpenAd = ad;
+                            loadTime = new Date().getTime();
+
+                            fireEvent("on.appopen.loaded", null);
+                        }
+
+                        @Override
+                        public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                            isLoadingAd = false;
+
+                            try {
+                                JSONObject errData = new JSONObject();
+                                errData.put("code", loadAdError.getCode());
+                                errData.put("message", loadAdError.getMessage());
+                                fireEvent("on.appopen.failed.load", errData);
+                            } catch (JSONException e) {}
+                        }
+                    }
+            );
+        });
+    }
+
+    public void showAdIfAvailable(@NonNull Activity activity) {
+        if (isShowingAd) return;
+
+        if (!isAdAvailable()) {
+            try {
+                JSONObject errData = new JSONObject();
+                errData.put("message", "Ad not ready or expired");
+                fireEvent("on.appopen.failed.show", errData);
+            } catch (JSONException e) {}
+
+            if (currentAdUnitId != null) loadAdInternal(currentAdUnitId, null);
+            return;
+        }
+
+        appOpenAd.setAdEventCallback(new AppOpenAdEventCallback() {
+
+            @Override
+            public void onAdPaid(@NonNull AdValue adValue) {
+                try {
+                    JSONObject data = new JSONObject();
+                    data.put("value", adValue.getValueMicros());
+                    data.put("currency", adValue.getCurrencyCode());
+                    data.put("precision", adValue.getPrecisionType());
+                    fireEvent("on.appopen.revenue", data);
+                } catch (JSONException e) {}
+            }
+
+            @Override
+            public void onAdShowedFullScreenContent() {
+                isShowingAd = true;
+                fireEvent("on.appopen.shown", null);
+            }
+
+            @Override
+            public void onAdDismissedFullScreenContent() {
+                appOpenAd = null;
+                isShowingAd = false;
+                fireEvent("on.appopen.dismissed", null);
+
+                if (currentAdUnitId != null) {
+                    loadAdInternal(currentAdUnitId, null);
+                }
+            }
+
+            @Override
+            public void onAdFailedToShowFullScreenContent(@NonNull FullScreenContentError error) {
+                appOpenAd = null;
+                isShowingAd = false;
+                try {
+                    JSONObject errData = new JSONObject();
+                    errData.put("code", error.getCode());
+                    errData.put("message", error.getMessage());
+                    fireEvent("on.appopen.failed.show", errData);
+                } catch (JSONException e) {}
+
+                if (currentAdUnitId != null) {
+                    loadAdInternal(currentAdUnitId, null);
+                }
+            }
+
+            @Override
+            public void onAdImpression() {
+                fireEvent("on.appopen.impression", null);
+            }
+
+            @Override
+            public void onAdClicked() {
+                fireEvent("on.appopen.clicked", null);
+            }
+        });
+
+        isShowingAd = true;
+        cordova.getActivity().runOnUiThread(() -> {
+            appOpenAd.show(activity);
+        });
+    }
+
+    public boolean shouldAutoShow() {
+        return this.isAutoShow;
+    }
+
+    public void setAutoShow(boolean value) {
+        this.isAutoShow = value;
+    }
+
+    private boolean wasLoadTimeLessThanNHoursAgo(long numHours) {
+        long dateDifference = new Date().getTime() - loadTime;
+        long numMilliSecondsPerHour = 3600000L;
+        return dateDifference < (numMilliSecondsPerHour * numHours);
+    }
+
+    private boolean isAdAvailable() {
+        return appOpenAd != null && wasLoadTimeLessThanNHoursAgo(4);
+    }
+
+    private void fireEvent(String eventName, JSONObject data) {
+        if (cordova == null) return;
+        cordova.getActivity().runOnUiThread(() -> {
+            StringBuilder js = new StringBuilder();
+            js.append("javascript:cordova.fireDocumentEvent('");
+            js.append(eventName);
+            js.append("'");
+            if (data != null) {
+                js.append(", ");
+                js.append(data.toString());
+            }
+            js.append(");");
+            if (webView != null && webView.getView() != null) webView.loadUrl(js.toString());
+        });
+    }
+}