cordova-plugin-admob-nextgen 1.0.0

package/src/android/GlobalSettingsExecutor.java

@@ -0,0 +1,139 @@
+package com.emi.cordova.admob.nextgen;
+
+import android.util.Log;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import com.google.android.libraries.ads.mobile.sdk.MobileAds;
+import com.google.android.libraries.ads.mobile.sdk.common.RequestConfiguration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GlobalSettingsExecutor {
+
+    private static final String TAG = "AdMobSettings";
+    private CordovaInterface cordova;
+
+    public GlobalSettingsExecutor(CordovaInterface cordova) {
+        this.cordova = cordova;
+    }
+
+    public void setAppVolume(JSONArray args, CallbackContext callbackContext) {
+        try {
+            double volume = args.getDouble(0);
+            MobileAds.setUserControlledAppVolume((float) volume);
+            callbackContext.success();
+        } catch (JSONException e) {
+            callbackContext.error("Invalid volume value");
+        }
+    }
+
+    public void setAppMuted(JSONArray args, CallbackContext callbackContext) {
+        try {
+            boolean muted = args.getBoolean(0);
+            MobileAds.setUserMutedApp(muted);
+            callbackContext.success();
+        } catch (JSONException e) {
+            callbackContext.error("Invalid mute value");
+        }
+    }
+
+    public void setRequestConfiguration(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject config = args.getJSONObject(0);
+            RequestConfiguration requestConfiguration = buildRequestConfiguration(config);
+
+            MobileAds.setRequestConfiguration(requestConfiguration);
+            callbackContext.success("Configuration Updated");
+        } catch (JSONException e) {
+            callbackContext.error("Config Error: " + e.getMessage());
+        }
+    }
+
+    public static RequestConfiguration buildRequestConfiguration(JSONObject config) {
+        RequestConfiguration.Builder builder = new RequestConfiguration.Builder();
+
+        try {
+
+            RequestConfiguration.TagForChildDirectedTreatment coppaTag = parseChildDirectedTag(config, "tagForChildDirectedTreatment");
+            builder.setTagForChildDirectedTreatment(coppaTag);
+
+            RequestConfiguration.TagForUnderAgeOfConsent tfuaTag = parseUnderAgeTag(config, "tagForUnderAgeOfConsent");
+            builder.setTagForUnderAgeOfConsent(tfuaTag);
+
+            if (config.has("maxAdContentRating")) {
+                String rating = config.getString("maxAdContentRating");
+                if ("G".equals(rating)) builder.setMaxAdContentRating(RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_G);
+                else if ("PG".equals(rating)) builder.setMaxAdContentRating(RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_PG);
+                else if ("T".equals(rating)) builder.setMaxAdContentRating(RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_T);
+                else if ("MA".equals(rating)) builder.setMaxAdContentRating(RequestConfiguration.MaxAdContentRating.MAX_AD_CONTENT_RATING_MA);
+            }
+
+            if (config.has("testDeviceIds")) {
+                JSONArray ids = config.getJSONArray("testDeviceIds");
+                List<String> testDevices = new ArrayList<>();
+                for (int i = 0; i < ids.length(); i++) {
+                    testDevices.add(ids.getString(i));
+                }
+                builder.setTestDeviceIds(testDevices);
+            }
+        } catch (JSONException e) {
+
+        }
+
+        return builder.build();
+    }
+
+    private static RequestConfiguration.TagForChildDirectedTreatment parseChildDirectedTag(JSONObject config, String key) {
+        if (!config.has(key) || config.isNull(key)) {
+            return RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED;
+        }
+
+        if (config.optBoolean(key, false) || !config.optBoolean(key, true)) { 
+            Object val = config.opt(key);
+            if (val instanceof Boolean) {
+                return (Boolean) val ?
+                        RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE :
+                        RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE;
+            }
+        }
+
+        String valStr = config.optString(key);
+        if ("true".equalsIgnoreCase(valStr)) {
+            return RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE;
+        }
+        if ("false".equalsIgnoreCase(valStr)) {
+            return RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE;
+        }
+
+        return RequestConfiguration.TagForChildDirectedTreatment.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED;
+    }
+
+    private static RequestConfiguration.TagForUnderAgeOfConsent parseUnderAgeTag(JSONObject config, String key) {
+        if (!config.has(key) || config.isNull(key)) {
+            return RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED;
+        }
+
+        Object val = config.opt(key);
+        if (val instanceof Boolean) {
+            return (Boolean) val ?
+                    RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE :
+                    RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE;
+        }
+
+        String valStr = config.optString(key);
+        if ("true".equalsIgnoreCase(valStr)) {
+            return RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE;
+        }
+        if ("false".equalsIgnoreCase(valStr)) {
+            return RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE;
+        }
+
+        return RequestConfiguration.TagForUnderAgeOfConsent.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED;
+    }
+}

package/src/android/InterstitialExecutor.java

@@ -0,0 +1,223 @@
+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 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;
+import com.google.android.libraries.ads.mobile.sdk.interstitial.InterstitialAd;
+import com.google.android.libraries.ads.mobile.sdk.interstitial.InterstitialAdEventCallback;
+
+import java.util.Date;
+
+public class InterstitialExecutor {
+
+    private static final String TAG = "AdMobInterstitial";
+    private CordovaInterface cordova;
+    private CordovaWebView webView; 
+
+    private InterstitialAd interstitialAd;
+
+    private boolean isLoading = false;
+    private boolean isAutoShow = true;
+
+    private long lastLoadTime = 0;
+    private long minLoadInterval = 5000; 
+
+    public InterstitialExecutor(CordovaInterface cordova, CordovaWebView webView) {
+        this.cordova = cordova;
+        this.webView = webView;
+    }
+
+    public void createInterstitial(JSONArray args, CallbackContext callbackContext) {
+        try {
+            JSONObject options = args.getJSONObject(0);
+            String adUnitId = options.getString("adUnitId");
+
+            if (options.has("isAutoShow")) {
+                this.isAutoShow = options.getBoolean("isAutoShow");
+            } else {
+                this.isAutoShow = true;
+            }
+
+            if (options.has("retryInterval")) {
+                this.minLoadInterval = options.getLong("retryInterval");
+            }
+
+            loadInterstitial(adUnitId, callbackContext);
+
+        } catch (JSONException e) {
+            callbackContext.error("Invalid JSON Args: " + e.getMessage());
+        }
+    }
+
+    private void loadInterstitial(String adUnitId, CallbackContext requestCallback) {
+        long currentTime = new Date().getTime();
+
+        if (isLoading) {
+
+            return;
+        }
+
+        if (interstitialAd != null) {
+
+            fireEvent("on.interstitial.loaded", null);
+            return;
+        }
+
+        if ((currentTime - lastLoadTime) < minLoadInterval) {
+
+            return;
+        }
+
+        isLoading = true;
+        lastLoadTime = currentTime;
+
+        PluginResult r = new PluginResult(PluginResult.Status.OK, "Loading started...");
+        requestCallback.sendPluginResult(r);
+
+        cordova.getThreadPool().execute(() -> {
+            AdRequest request = new AdRequest.Builder(adUnitId).build();
+
+            InterstitialAd.load(
+                    request,
+                    new AdLoadCallback<InterstitialAd>() {
+                        @Override
+                        public void onAdLoaded(@NonNull InterstitialAd ad) {
+                            isLoading = false;
+                            interstitialAd = ad;
+
+                            fireEvent("on.interstitial.loaded", null);
+
+                            if (isAutoShow) {
+                                showInterstitialAd();
+                            }
+                        }
+
+                        @Override
+                        public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                            isLoading = false;
+                            interstitialAd = null;
+
+                            try {
+                                JSONObject errData = new JSONObject();
+                                errData.put("code", loadAdError.getCode());
+                                errData.put("message", loadAdError.getMessage());
+                                fireEvent("on.interstitial.failed.load", errData);
+                            } catch (JSONException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+            );
+        });
+    }
+
+    public void showInterstitial(CallbackContext callbackContext) {
+        cordova.getActivity().runOnUiThread(() -> {
+            if (interstitialAd != null) {
+                showInterstitialAd();
+                callbackContext.success();
+            } else {
+                callbackContext.error("Ad not ready");
+            }
+        });
+    }
+
+    private void showInterstitialAd() {
+        if (interstitialAd == null) return;
+
+        Activity activity = cordova.getActivity();
+
+        activity.runOnUiThread(() -> {
+            interstitialAd.setAdEventCallback(new InterstitialAdEventCallback() {
+
+                @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.interstitial.revenue", data);
+                    } catch (JSONException e) {
+
+                    }
+                }
+
+                @Override
+                public void onAdShowedFullScreenContent() {
+
+                    fireEvent("on.interstitial.shown", null);
+                }
+
+                @Override
+                public void onAdDismissedFullScreenContent() {
+
+                    interstitialAd = null;
+                    isLoading = false;
+                    fireEvent("on.interstitial.dismissed", null);
+                }
+
+                @Override
+                public void onAdFailedToShowFullScreenContent(@NonNull FullScreenContentError error) {
+
+                    interstitialAd = null;
+                    try {
+                        JSONObject errData = new JSONObject();
+                        errData.put("message", error.getMessage());
+                        fireEvent("on.interstitial.failed.show", errData);
+                    } catch (JSONException e) {}
+                }
+
+                @Override
+                public void onAdImpression() {
+                    fireEvent("on.interstitial.impression", null);
+                }
+
+                @Override
+                public void onAdClicked() {
+                    fireEvent("on.interstitial.clicked", null);
+                }
+            });
+
+                interstitialAd.show(activity);
+        });
+    }
+
+    private void fireEvent(String eventName, JSONObject data) {
+        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(");");
+
+            String jsCommand = js.toString();
+
+            if (webView != null) {
+                webView.loadUrl(jsCommand);
+            }
+        });
+    }
+}