cordova-admob-tomitank 1.0.0

package/src/android/cordova/AdMob.java

@@ -0,0 +1,256 @@
+package admob.plus.cordova;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.util.Log;
+
+import com.google.android.gms.ads.MobileAds;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import admob.plus.cordova.Generated.Actions;
+import admob.plus.cordova.ads.AdBase;
+import admob.plus.cordova.ads.AppOpen;
+import admob.plus.cordova.ads.Banner;
+import admob.plus.cordova.ads.Interstitial;
+import admob.plus.cordova.ads.Native;
+import admob.plus.cordova.ads.Rewarded;
+import admob.plus.cordova.ads.RewardedInterstitial;
+import admob.plus.core.GenericAd;
+import admob.plus.core.Helper;
+
+import static admob.plus.core.Helper.ads;
+
+
+public class AdMob extends CordovaPlugin implements Helper.Adapter {
+    public static final String NATIVE_VIEW_DEFAULT = Native.VIEW_DEFAULT_KEY;
+    private static final String TAG = "AdMobPlus";
+    private final ArrayList<PluginResult> eventQueue = new ArrayList<PluginResult>();
+    public Helper helper;
+    private CallbackContext readyCallbackContext = null;
+
+    public static void registerNativeAdViewProviders(Map<String, Native.ViewProvider> providers) {
+        Native.providers.putAll(providers);
+    }
+
+    @Override
+    protected void pluginInitialize() {
+        super.pluginInitialize();
+        Log.i(TAG, "Initialize plugin");
+
+        helper = new Helper(this);
+        ExecuteContext.plugin = this;
+    }
+
+    @Override
+    public boolean execute(String actionKey, JSONArray args, CallbackContext callbackContext) {
+        Log.d(TAG, String.format("Execute %s", actionKey));
+        ExecuteContext ctx = new ExecuteContext(actionKey, args, callbackContext);
+
+        switch (actionKey) {
+            case Actions.READY:
+                return executeReady(callbackContext);
+            case Actions.START:
+                MobileAds.initialize(cordova.getActivity(), status -> {
+                    helper.configForTestLab();
+                    callbackContext.success(new JSONObject(new HashMap<String, Object>() {{
+                        put("version", MobileAds.getVersion());
+                    }}));
+                });
+                break;
+            case Actions.CONFIGURE:
+            case Actions.CONFIG_REQUEST:
+                ctx.configure(helper);
+                break;
+            case Actions.AD_CREATE:
+                String adClass = ctx.optString("cls");
+                if (adClass == null) {
+                    ctx.reject("ad cls is missing");
+                } else {
+                    GenericAd ad = null;
+                    switch (adClass) {
+                        case "AppOpenAd":
+                            ad = new AppOpen(ctx);
+                            break;
+                        case "BannerAd":
+                            ad = new Banner(ctx);
+                            break;
+                        case "InterstitialAd":
+                            ad = new Interstitial(ctx);
+                            break;
+                        case "NativeAd":
+                            ad = new Native(ctx);
+                            break;
+                        case "RewardedAd":
+                            ad = new Rewarded(ctx);
+                            break;
+                        case "RewardedInterstitialAd":
+                            ad = new RewardedInterstitial(ctx);
+                            break;
+                    }
+                    if (ad != null) {
+                        ctx.resolve();
+                    } else {
+                        ctx.reject("ad cls is not supported");
+                    }
+                }
+                break;
+            case Actions.AD_IS_LOADED:
+                return executeAdIsLoaded_(ctx);
+            case Actions.AD_LOAD:
+                return executeAdLoad(ctx);
+            case Actions.AD_SHOW:
+                return executeAdShow(ctx);
+            case Actions.AD_HIDE:
+                return executeAdHide(ctx);
+            case Actions.SET_APP_MUTED: {
+                boolean value = args.optBoolean(0);
+                MobileAds.setAppMuted(value);
+                callbackContext.success();
+                break;
+            }
+            case Actions.SET_APP_VOLUME: {
+                float value = BigDecimal.valueOf(args.optDouble(0)).floatValue();
+                MobileAds.setAppVolume(value);
+                callbackContext.success();
+                break;
+            }
+            default:
+                return false;
+        }
+
+        return true;
+    }
+
+    private boolean executeReady(CallbackContext callbackContext) {
+        if (readyCallbackContext == null) {
+            for (PluginResult result : eventQueue) {
+                callbackContext.sendPluginResult(result);
+            }
+            eventQueue.clear();
+        } else {
+            Log.e(TAG, "Ready action should only be called once.");
+        }
+        readyCallbackContext = callbackContext;
+        emit(Generated.Events.READY, new HashMap<String, Object>() {{
+            put("isRunningInTestLab", helper.isRunningInTestLab());
+        }});
+        return true;
+    }
+
+    private boolean executeAdIsLoaded_(ExecuteContext ctx) {
+        cordova.getActivity().runOnUiThread(() -> {
+            GenericAd ad = (GenericAd) ctx.optAdOrError();
+            if (ad != null) {
+                ctx.resolve(ad.isLoaded());
+            }
+        });
+        return true;
+    }
+
+    private boolean executeAdLoad(ExecuteContext ctx) {
+        cordova.getActivity().runOnUiThread(() -> {
+            GenericAd ad = (GenericAd) ctx.optAdOrError();
+            if (ad != null) {
+                ad.load(ctx);
+            }
+        });
+        return true;
+    }
+
+    private boolean executeAdShow(ExecuteContext ctx) {
+        cordova.getActivity().runOnUiThread(() -> {
+            GenericAd ad = (GenericAd) ctx.optAdOrError();
+            if (ad != null) {
+                if (ad.isLoaded()) {
+                    ad.show(ctx);
+                } else {
+                    ctx.resolve(false);
+                }
+            }
+        });
+        return true;
+    }
+
+    private boolean executeAdHide(ExecuteContext ctx) {
+        cordova.getActivity().runOnUiThread(() -> {
+            GenericAd ad = (GenericAd) ctx.optAdOrError();
+            if (ad != null) {
+                ad.hide(ctx);
+            }
+        });
+        return true;
+    }
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+
+        for (int i = 0; i < ads.size(); i++) {
+            AdBase ad = (AdBase) ads.valueAt(i);
+            ad.onConfigurationChanged(newConfig);
+        }
+    }
+
+    @Override
+    public void onPause(boolean multitasking) {
+        for (int i = 0; i < ads.size(); i++) {
+            AdBase ad = (AdBase) ads.valueAt(i);
+            ad.onPause(multitasking);
+        }
+        super.onPause(multitasking);
+    }
+
+    @Override
+    public void onResume(boolean multitasking) {
+        super.onResume(multitasking);
+        for (int i = 0; i < ads.size(); i++) {
+            AdBase ad = (AdBase) ads.valueAt(i);
+            ad.onResume(multitasking);
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        readyCallbackContext = null;
+
+        for (int i = 0; i < ads.size(); i++) {
+            AdBase ad = (AdBase) ads.valueAt(i);
+            ad.onDestroy();
+        }
+
+        Banner.destroyParentView();
+
+        super.onDestroy();
+    }
+
+    @Override
+    public Activity getActivity() {
+        return cordova.getActivity();
+    }
+
+    @Override
+    public void emit(String eventName, Map<String, Object> data) {
+        JSONObject event = new JSONObject(new HashMap<String, Object>() {{
+            put("type", eventName);
+            put("data", data);
+        }});
+
+        PluginResult result = new PluginResult(PluginResult.Status.OK, event);
+        result.setKeepCallback(true);
+        if (readyCallbackContext == null) {
+            eventQueue.add(result);
+        } else {
+            readyCallbackContext.sendPluginResult(result);
+        }
+    }
+}

package/src/android/cordova/ExecuteContext.java

@@ -0,0 +1,174 @@
+package admob.plus.cordova;
+
+import android.app.Activity;
+import android.content.res.Resources;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.gms.ads.AdSize;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+import admob.plus.cordova.ads.Banner.AdSizeType;
+import admob.plus.core.Ad;
+import admob.plus.core.Context;
+import admob.plus.core.Helper;
+
+import static admob.plus.core.Helper.jsonArray2stringList;
+
+public class ExecuteContext implements Context {
+    public static AdMob plugin;
+    public final String actionKey;
+    public final JSONArray args;
+    public final CallbackContext callbackContext;
+    public final JSONObject opts;
+
+    ExecuteContext(String actionKey, JSONArray args, CallbackContext callbackContext) {
+        this.actionKey = actionKey;
+        this.args = args;
+        this.callbackContext = callbackContext;
+        this.opts = args.optJSONObject(0);
+    }
+
+    @Override
+    public boolean has(String name) {
+        return opts.has(name);
+    }
+
+    @Nullable
+    @Override
+    public Object opt(@Nullable String name) {
+        return opts.opt(name);
+    }
+
+    @Nullable
+    @Override
+    public Boolean optBoolean(@Nullable String name) {
+        if (!opts.has(name)) return null;
+        return opts.optBoolean(name);
+    }
+
+    @Nullable
+    @Override
+    public Double optDouble(@Nullable String name) {
+        if (!opts.has(name)) return null;
+        return opts.optDouble(name);
+    }
+
+    @Nullable
+    @Override
+    public Integer optInt(@Nullable String name) {
+        if (!opts.has(name)) return null;
+        return opts.optInt(name);
+    }
+
+    @Nullable
+    @Override
+    public String optString(String name) {
+        if (!opts.has(name)) return null;
+        return opts.optString(name);
+    }
+
+    @NonNull
+    @Override
+    public List<String> optStringList(@Nullable String name) {
+        return jsonArray2stringList(opts.optJSONArray(name));
+    }
+
+    @Nullable
+    @Override
+    public JSONObject optObject(@Nullable String name) {
+        return opts.optJSONObject(name);
+    }
+
+    @Override
+    public void resolve() {
+        callbackContext.success();
+    }
+
+    @Override
+    public void resolve(boolean data) {
+        PluginResult result = new PluginResult(PluginResult.Status.OK, data);
+        sendResult(result);
+    }
+
+    @Override
+    public void reject(String msg) {
+        callbackContext.error(msg);
+    }
+
+    @Nullable
+    public Integer optOffset() {
+        if (opts.has("offset")) {
+            return opts.optInt("offset");
+        }
+        return null;
+    }
+
+    @Nullable
+    public <T extends Ad> T optAdOrCreate(Class<T> type) {
+        Ad adOrNull = optAd();
+        if (adOrNull != null) {
+            try {
+                return type.cast(adOrNull);
+            } catch (ClassCastException e) {
+                this.reject("Wrong ad type");
+                return null;
+            }
+        }
+        try {
+            return type.getDeclaredConstructor(ExecuteContext.class).newInstance(this);
+        } catch (IllegalAccessException | InstantiationException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+            this.reject("Fail to create ad");
+        }
+        return null;
+    }
+
+    public AdSize optAdSize() {
+        final String name = "size";
+        if (!opts.has(name)) {
+            return AdSize.SMART_BANNER;
+        }
+        JSONObject adSizeObj = opts.optJSONObject(name);
+        AdSize adSize = AdSizeType.getAdSize(opts.optInt(name));
+        if (adSizeObj == null) {
+            if (adSize != null) {
+                return adSize;
+            }
+            return AdSize.SMART_BANNER;
+        }
+        String adaptive = adSizeObj.optString("adaptive");
+        int w = Helper.pxToDp(adSizeObj.has("width") ? adSizeObj.optInt("width") : Resources.getSystem().getDisplayMetrics().widthPixels);
+        if ("inline".equals(adaptive)) {
+            if (adSizeObj.has("maxHeight")) {
+                return AdSize.getInlineAdaptiveBannerAdSize(w, Helper.pxToDp(adSizeObj.optInt("maxHeight")));
+            }
+        } else {
+            switch (adSizeObj.optString("orientation")) {
+                case "portrait":
+                    return AdSize.getPortraitAnchoredAdaptiveBannerAdSize(getActivity(), w);
+                case "landscape":
+                    return AdSize.getLandscapeAnchoredAdaptiveBannerAdSize(getActivity(), w);
+                default:
+                    return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(getActivity(), w);
+            }
+        }
+        return new AdSize(w, Helper.pxToDp(adSizeObj.optInt("height")));
+    }
+
+    public Activity getActivity() {
+        return plugin.cordova.getActivity();
+    }
+
+    public void sendResult(PluginResult result) {
+        callbackContext.sendPluginResult(result);
+    }
+}

package/src/android/cordova/Generated.java

@@ -0,0 +1,72 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+package admob.plus.cordova;
+
+public final class Generated {
+    public static final class Actions {
+        public static final String AD_CREATE = "adCreate";
+        public static final String AD_HIDE = "adHide";
+        public static final String AD_IS_LOADED = "adIsLoaded";
+        public static final String AD_LOAD = "adLoad";
+        public static final String AD_SHOW = "adShow";
+        public static final String BANNER_CONFIG = "bannerConfig";
+        public static final String BANNER_HIDE = "bannerHide";
+        public static final String BANNER_LOAD = "bannerLoad";
+        public static final String BANNER_SHOW = "bannerShow";
+        public static final String CONFIGURE = "configure";
+        public static final String CONFIG_REQUEST = "configRequest";
+        public static final String INTERSTITIAL_IS_LOADED = "interstitialIsLoaded";
+        public static final String INTERSTITIAL_LOAD = "interstitialLoad";
+        public static final String INTERSTITIAL_SHOW = "interstitialShow";
+        public static final String READY = "ready";
+        public static final String REQUEST_TRACKING_AUTHORIZATION = "requestTrackingAuthorization";
+        public static final String REWARDED_INTERSTITIAL_IS_LOADED = "rewardedInterstitialIsLoaded";
+        public static final String REWARDED_INTERSTITIAL_LOAD = "rewardedInterstitialLoad";
+        public static final String REWARDED_INTERSTITIAL_SHOW = "rewardedInterstitialShow";
+        public static final String REWARDED_IS_LOADED = "rewardedIsLoaded";
+        public static final String REWARDED_LOAD = "rewardedLoad";
+        public static final String REWARDED_SHOW = "rewardedShow";
+        public static final String SET_APP_MUTED = "setAppMuted";
+        public static final String SET_APP_VOLUME = "setAppVolume";
+        public static final String START = "start";
+    }
+
+    public static final class Events {
+        public static final String AD_CLICK = "admob.ad.click";
+        public static final String AD_DISMISS = "admob.ad.dismiss";
+        public static final String AD_IMPRESSION = "admob.ad.impression";
+        public static final String AD_LOAD = "admob.ad.load";
+        public static final String AD_LOAD_FAIL = "admob.ad.loadfail";
+        public static final String AD_REWARD = "admob.ad.reward";
+        public static final String AD_SHOW = "admob.ad.show";
+        public static final String AD_SHOW_FAIL = "admob.ad.showfail";
+        public static final String BANNER_CLICK = "admob.banner.click";
+        public static final String BANNER_CLOSE = "admob.banner.close";
+        public static final String BANNER_IMPRESSION = "admob.banner.impression";
+        public static final String BANNER_LOAD = "admob.banner.load";
+        public static final String BANNER_LOAD_FAIL = "admob.banner.loadfail";
+        public static final String BANNER_OPEN = "admob.banner.open";
+        public static final String BANNER_SIZE = "admob.banner.size";
+        public static final String BANNER_SIZE_CHANGE = "admob.banner.sizechange";
+        public static final String INTERSTITIAL_DISMISS = "admob.interstitial.dismiss";
+        public static final String INTERSTITIAL_IMPRESSION = "admob.interstitial.impression";
+        public static final String INTERSTITIAL_LOAD = "admob.interstitial.load";
+        public static final String INTERSTITIAL_LOAD_FAIL = "admob.interstitial.loadfail";
+        public static final String INTERSTITIAL_SHOW = "admob.interstitial.show";
+        public static final String INTERSTITIAL_SHOW_FAIL = "admob.interstitial.showfail";
+        public static final String READY = "admob.ready";
+        public static final String REWARDED_DISMISS = "admob.rewarded.dismiss";
+        public static final String REWARDED_IMPRESSION = "admob.rewarded.impression";
+        public static final String REWARDED_INTERSTITIAL_DISMISS = "admob.rewardedi.dismiss";
+        public static final String REWARDED_INTERSTITIAL_IMPRESSION = "admob.rewardedi.impression";
+        public static final String REWARDED_INTERSTITIAL_LOAD = "admob.rewardedi.load";
+        public static final String REWARDED_INTERSTITIAL_LOAD_FAIL = "admob.rewardedi.loadfail";
+        public static final String REWARDED_INTERSTITIAL_REWARD = "admob.rewardedi.reward";
+        public static final String REWARDED_INTERSTITIAL_SHOW = "admob.rewardedi.show";
+        public static final String REWARDED_INTERSTITIAL_SHOW_FAIL = "admob.rewardedi.showfail";
+        public static final String REWARDED_LOAD = "admob.rewarded.load";
+        public static final String REWARDED_LOAD_FAIL = "admob.rewarded.loadfail";
+        public static final String REWARDED_REWARD = "admob.rewarded.reward";
+        public static final String REWARDED_SHOW = "admob.rewarded.show";
+        public static final String REWARDED_SHOW_FAIL = "admob.rewarded.showfail";
+    }
+}

package/src/android/cordova/ads/AdBase.java

@@ -0,0 +1,54 @@
+package admob.plus.cordova.ads;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.google.android.gms.ads.AdRequest;
+
+import org.apache.cordova.CordovaWebView;
+
+import admob.plus.cordova.ExecuteContext;
+import admob.plus.core.Ad;
+import admob.plus.core.GenericAd;
+import admob.plus.core.Helper;
+
+public abstract class AdBase extends Ad implements GenericAd  {
+    protected AdRequest adRequest;
+
+    public AdBase(ExecuteContext ctx) {
+        super(ctx);
+        adRequest = ctx.optAdRequest();
+    }
+
+    public void onConfigurationChanged(Configuration newConfig) {
+    }
+
+    public void onPause(boolean multitasking) {
+    }
+
+    public void onResume(boolean multitasking) {
+    }
+
+    public void onDestroy() {
+        super.destroy();
+    }
+
+    protected CordovaWebView getCordovaWebView() {
+        return ExecuteContext.plugin.webView;
+    }
+
+    protected View getWebView() {
+        return getCordovaWebView().getView();
+    }
+
+    protected ViewGroup getWebViewParent() {
+        return (ViewGroup) getWebView().getParent();
+    }
+
+    @Override
+    protected Helper.Adapter getAdapter() {
+        return ExecuteContext.plugin;
+    }
+}

package/src/android/cordova/ads/AppOpen.java

@@ -0,0 +1,98 @@
+package admob.plus.cordova.ads;
+
+import com.google.android.gms.ads.AdError;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.FullScreenContentCallback;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.appopen.AppOpenAd;
+
+import admob.plus.cordova.ExecuteContext;
+import admob.plus.cordova.Generated.Events;
+import admob.plus.core.Context;
+
+public class AppOpen extends AdBase {
+    private final AdRequest mAdRequest;
+    private final int mOrientation;
+    private AppOpenAd mAd = null;
+
+    public AppOpen(ExecuteContext ctx) {
+        super(ctx);
+
+        mAdRequest = ctx.optAdRequest();
+
+        Integer o = ctx.optInt("orientation");
+        mOrientation = o == null || o == 1 || o == 2 ? AppOpenAd.APP_OPEN_AD_ORIENTATION_PORTRAIT : AppOpenAd.APP_OPEN_AD_ORIENTATION_LANDSCAPE;
+    }
+
+    @Override
+    public void onDestroy() {
+        clear();
+
+        super.onDestroy();
+    }
+
+    @Override
+    public void load(Context ctx) {
+        clear();
+
+        AppOpenAd.load(getActivity(),
+                adUnitId,
+                mAdRequest,
+                mOrientation, new AppOpenAd.AppOpenAdLoadCallback() {
+                    @Override
+                    public void onAdLoaded(AppOpenAd ad) {
+                        mAd = ad;
+                        ad.setFullScreenContentCallback(new FullScreenContentCallback() {
+                            @Override
+                            public void onAdDismissedFullScreenContent() {
+                                clear();
+                                emit(Events.AD_DISMISS);
+                            }
+
+                            @Override
+                            public void onAdFailedToShowFullScreenContent(AdError adError) {
+                                clear();
+                                emit(Events.AD_SHOW_FAIL, adError);
+                            }
+
+                            @Override
+                            public void onAdShowedFullScreenContent() {
+                                emit(Events.AD_SHOW);
+                            }
+
+                            @Override
+                            public void onAdImpression() {
+                                emit(Events.AD_IMPRESSION);
+                            }
+                        });
+
+                        emit(Events.AD_LOAD);
+                        ctx.resolve();
+                    }
+
+                    @Override
+                    public void onAdFailedToLoad(LoadAdError loadAdError) {
+                        clear();
+                        emit(Events.AD_LOAD_FAIL, loadAdError);
+                        ctx.reject(loadAdError.toString());
+                    }
+                });
+    }
+
+    @Override
+    public boolean isLoaded() {
+        return mAd != null;
+    }
+
+    @Override
+    public void show(Context ctx) {
+        mAd.show(getActivity());
+        ctx.resolve(true);
+    }
+
+    private void clear() {
+        if (mAd != null) {
+            mAd = null;
+        }
+    }
+}