cordova-admob-tomitank 1.0.0

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

@@ -0,0 +1,108 @@
+package admob.plus.cordova.ads;
+
+import androidx.annotation.NonNull;
+
+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.rewarded.RewardedAd;
+import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback;
+import com.google.android.gms.ads.rewarded.ServerSideVerificationOptions;
+
+import admob.plus.cordova.ExecuteContext;
+import admob.plus.cordova.Generated.Events;
+import admob.plus.core.Context;
+
+public class Rewarded extends AdBase {
+    private RewardedAd mAd = null;
+
+    public Rewarded(ExecuteContext ctx) {
+        super(ctx);
+    }
+
+    @Override
+    public void onDestroy() {
+        clear();
+
+        super.onDestroy();
+    }
+
+    @Override
+    public void load(Context ctx) {
+        clear();
+
+        RewardedAd.load(getActivity(), adUnitId, adRequest, new RewardedAdLoadCallback() {
+            @Override
+            public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                mAd = null;
+                emit(Events.AD_LOAD_FAIL, loadAdError);
+                emit(Events.REWARDED_LOAD_FAIL, loadAdError);
+                ctx.reject(loadAdError.toString());
+            }
+
+            @Override
+            public void onAdLoaded(@NonNull RewardedAd rewardedAd) {
+                mAd = rewardedAd;
+                ServerSideVerificationOptions ssv = ctx.optServerSideVerificationOptions();
+                if (ssv != null) {
+                    mAd.setServerSideVerificationOptions(ssv);
+                }
+                mAd.setFullScreenContentCallback(new FullScreenContentCallback() {
+                    @Override
+                    public void onAdDismissedFullScreenContent() {
+                        emit(Events.AD_DISMISS);
+                        emit(Events.REWARDED_DISMISS);
+                    }
+
+                    @Override
+                    public void onAdFailedToShowFullScreenContent(AdError adError) {
+                        emit(Events.AD_SHOW_FAIL, adError);
+                        emit(Events.REWARDED_SHOW_FAIL, adError);
+                    }
+
+                    @Override
+                    public void onAdShowedFullScreenContent() {
+                        clear();
+                        emit(Events.AD_SHOW);
+                        emit(Events.REWARDED_SHOW);
+                    }
+
+                    @Override
+                    public void onAdImpression() {
+                        emit(Events.AD_IMPRESSION);
+                        emit(Events.REWARDED_IMPRESSION);
+                    }
+                });
+
+                emit(Events.AD_LOAD);
+                emit(Events.REWARDED_LOAD);
+                ctx.resolve();
+            }
+        });
+    }
+
+    @Override
+    public boolean isLoaded() {
+        return mAd != null;
+    }
+
+    @Override
+    public void show(Context ctx) {
+        if (isLoaded()) {
+            mAd.show(getActivity(), rewardItem -> {
+                emit(Events.AD_REWARD, rewardItem);
+                emit(Events.REWARDED_REWARD, rewardItem);
+            });
+            ctx.resolve();
+        } else {
+            ctx.reject("Ad is not loaded");
+        }
+    }
+
+    private void clear() {
+        if (mAd != null) {
+            mAd = null;
+        }
+    }
+}

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

@@ -0,0 +1,108 @@
+package admob.plus.cordova.ads;
+
+import androidx.annotation.NonNull;
+
+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.rewarded.ServerSideVerificationOptions;
+import com.google.android.gms.ads.rewardedinterstitial.RewardedInterstitialAd;
+import com.google.android.gms.ads.rewardedinterstitial.RewardedInterstitialAdLoadCallback;
+
+import admob.plus.cordova.ExecuteContext;
+import admob.plus.cordova.Generated.Events;
+import admob.plus.core.Context;
+
+public class RewardedInterstitial extends AdBase {
+    private RewardedInterstitialAd mAd = null;
+
+    public RewardedInterstitial(ExecuteContext ctx) {
+        super(ctx);
+    }
+
+    @Override
+    public void onDestroy() {
+        clear();
+
+        super.onDestroy();
+    }
+
+    @Override
+    public void load(Context ctx) {
+        clear();
+
+        RewardedInterstitialAd.load(getActivity(), adUnitId, adRequest, new RewardedInterstitialAdLoadCallback() {
+            @Override
+            public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                mAd = null;
+                emit(Events.AD_LOAD_FAIL, loadAdError);
+                emit(Events.REWARDED_INTERSTITIAL_LOAD_FAIL, loadAdError);
+                ctx.reject(loadAdError.toString());
+            }
+
+            @Override
+            public void onAdLoaded(@NonNull RewardedInterstitialAd rewardedAd) {
+                mAd = rewardedAd;
+                ServerSideVerificationOptions ssv = ctx.optServerSideVerificationOptions();
+                if (ssv != null) {
+                    mAd.setServerSideVerificationOptions(ssv);
+                }
+                mAd.setFullScreenContentCallback(new FullScreenContentCallback() {
+                    @Override
+                    public void onAdDismissedFullScreenContent() {
+                        emit(Events.AD_DISMISS);
+                        emit(Events.REWARDED_INTERSTITIAL_DISMISS);
+                    }
+
+                    @Override
+                    public void onAdFailedToShowFullScreenContent(AdError adError) {
+                        emit(Events.AD_SHOW_FAIL, adError);
+                        emit(Events.REWARDED_INTERSTITIAL_SHOW_FAIL, adError);
+                    }
+
+                    @Override
+                    public void onAdShowedFullScreenContent() {
+                        mAd = null;
+                        emit(Events.AD_SHOW);
+                        emit(Events.REWARDED_INTERSTITIAL_SHOW);
+                    }
+
+                    @Override
+                    public void onAdImpression() {
+                        emit(Events.AD_IMPRESSION);
+                        emit(Events.REWARDED_INTERSTITIAL_IMPRESSION);
+                    }
+                });
+
+                emit(Events.AD_LOAD);
+                emit(Events.REWARDED_INTERSTITIAL_LOAD);
+                ctx.resolve();
+            }
+        });
+    }
+
+    @Override
+    public boolean isLoaded() {
+        return mAd != null;
+    }
+
+    @Override
+    public void show(Context ctx) {
+        if (isLoaded()) {
+            mAd.show(getActivity(), rewardItem -> {
+                emit(Events.AD_REWARD, rewardItem);
+                emit(Events.REWARDED_INTERSTITIAL_REWARD, rewardItem);
+            });
+            ctx.resolve();
+        } else {
+            ctx.reject("Ad is not loaded");
+        }
+    }
+
+    private void clear() {
+        if (mAd != null) {
+            mAd = null;
+        }
+    }
+}

package/src/android/core/Ad.java

@@ -0,0 +1,73 @@
+package admob.plus.core;
+
+import android.app.Activity;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.gms.ads.AdError;
+import com.google.android.gms.ads.rewarded.RewardItem;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static admob.plus.core.Helper.ads;
+
+public abstract class Ad {
+    public final int id;
+    public final String adUnitId;
+
+    public Ad(int id, @NonNull String adUnitId) {
+        this.id = id;
+        this.adUnitId = adUnitId;
+        ads.put(id, this);
+    }
+
+    public Ad(Context ctx) {
+        this(Objects.requireNonNull(ctx.optId()), Objects.requireNonNull(ctx.optAdUnitID()));
+    }
+
+    public void destroy() {
+        ads.remove(id);
+    }
+
+    protected abstract Helper.Adapter getAdapter();
+
+    public Activity getActivity() {
+        return getAdapter().getActivity();
+    }
+
+    @Nullable
+    public ViewGroup getContentView() {
+        return getActivity().findViewById(android.R.id.content);
+    }
+
+    protected void emit(String eventName) {
+        this.emit(eventName, new HashMap<String, Object>());
+    }
+
+    protected void emit(String eventName, AdError error) {
+        this.emit(eventName, new HashMap<String, Object>() {{
+            put("code", error.getCode());
+            put("message", error.getMessage());
+            put("cause", error.getCause());
+        }});
+    }
+
+    protected void emit(String eventName, RewardItem rewardItem) {
+        this.emit(eventName, new HashMap<String, Object>() {{
+            put("reward", new HashMap<String, Object>() {{
+                put("amount", rewardItem.getAmount());
+                put("type", rewardItem.getType());
+            }});
+        }});
+    }
+
+    protected void emit(String eventName, Map<String, Object> data) {
+        getAdapter().emit(eventName, new HashMap<String, Object>(data) {{
+            put("adId", id);
+        }});
+    }
+}

package/src/android/core/Context.java

@@ -0,0 +1,186 @@
+package admob.plus.core;
+
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.ads.mediation.admob.AdMobAdapter;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.LoadAdError;
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.google.android.gms.ads.rewarded.ServerSideVerificationOptions;
+
+import org.json.JSONObject;
+
+import java.util.List;
+import java.util.Objects;
+
+public interface Context {
+    @Nullable
+    static Integer intFromBool(Context ctx, String name, int vNull, int vTrue, int vFalse) {
+        if (!ctx.has(name)) return null;
+        final Boolean v = ctx.optBoolean(name);
+        if (v == null) return vNull;
+        return v ? vTrue : vFalse;
+    }
+
+    boolean has(@NonNull String name);
+
+    @Nullable
+    Object opt(@NonNull String name);
+
+    @Nullable
+    Boolean optBoolean(@NonNull String name);
+
+    @Nullable
+    Double optDouble(@NonNull String name);
+
+    default double optDouble(@NonNull String name, double defaultValue) {
+        final Double v = optDouble(name);
+        if (v == null) return defaultValue;
+        return v;
+    }
+
+    @Nullable
+    default Float optFloat(@NonNull String name) {
+        final Double v = optDouble(name);
+        if (v == null) return null;
+        return v.floatValue();
+    }
+
+    @Nullable
+    Integer optInt(@NonNull String name);
+
+    @Nullable
+    String optString(@NonNull String name);
+
+    @NonNull
+    List<String> optStringList(@NonNull String name);
+
+    @Nullable
+    JSONObject optObject(@NonNull String name);
+
+    void resolve();
+
+    void resolve(boolean data);
+
+    void reject(String msg);
+
+    default void reject() {
+        reject("unknown error");
+    }
+
+    default void reject(@NonNull LoadAdError loadAdError) {
+        reject(loadAdError.getMessage());
+    }
+
+    @Nullable
+    default Integer optId() {
+        return this.optInt("id");
+    }
+
+    @Nullable
+    default Ad optAd() {
+        return Helper.getAd(optId());
+    }
+
+    @Nullable
+    default Ad optAdOrError() {
+        Ad ad = optAd();
+        if (ad == null) {
+            this.reject("Ad not found");
+        }
+        return ad;
+    }
+
+    @Nullable
+    default String optAdUnitID() {
+        return this.optString("adUnitId");
+    }
+
+    @Nullable
+    default Boolean optAppMuted() {
+        return this.optBoolean("appMuted");
+    }
+
+    @Nullable
+    default Float optAppVolume() {
+        return this.optFloat("appVolume");
+    }
+
+    @Nullable
+    default String optPosition() {
+        return this.optString("position");
+    }
+
+    @NonNull
+    default AdRequest optAdRequest() {
+        AdRequest.Builder builder = new AdRequest.Builder();
+        if (this.has("contentUrl")) {
+            builder.setContentUrl(Objects.requireNonNull(this.optString("contentUrl")));
+        }
+        Bundle extras = new Bundle();
+        if (this.has("npa")) {
+            extras.putString("npa", this.optString("npa"));
+        }
+        return builder.addNetworkExtrasBundle(AdMobAdapter.class, extras).build();
+    }
+
+    @NonNull
+    default RequestConfiguration optRequestConfiguration() {
+        final RequestConfiguration.Builder builder = new RequestConfiguration.Builder();
+        if (this.has("maxAdContentRating")) {
+            builder.setMaxAdContentRating(this.optString("maxAdContentRating"));
+        }
+        final Integer tagForChildDirectedTreatment = intFromBool(this, "tagForChildDirectedTreatment",
+                RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED,
+                RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE,
+                RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE);
+        if (tagForChildDirectedTreatment != null) {
+            builder.setTagForChildDirectedTreatment(tagForChildDirectedTreatment);
+        }
+        final Integer tagForUnderAgeOfConsent = intFromBool(this, "tagForUnderAgeOfConsent",
+                RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED,
+                RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE,
+                RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE);
+        if (tagForUnderAgeOfConsent != null) {
+            builder.setTagForUnderAgeOfConsent(tagForUnderAgeOfConsent);
+        }
+        if (this.has("testDeviceIds")) {
+            builder.setTestDeviceIds(this.optStringList("testDeviceIds"));
+        }
+        return builder.build();
+    }
+
+    @Nullable
+    default ServerSideVerificationOptions optServerSideVerificationOptions() {
+        final String param = "serverSideVerification";
+        JSONObject serverSideVerification = this.optObject(param);
+        if (serverSideVerification == null) return null;
+
+        ServerSideVerificationOptions.Builder builder = new ServerSideVerificationOptions.Builder();
+        if (serverSideVerification.has("customData")) {
+            builder.setCustomData(serverSideVerification.optString("customData"));
+        }
+        if (serverSideVerification.has("userId")) {
+            builder.setUserId(serverSideVerification.optString("userId"));
+        }
+        return builder.build();
+    }
+
+    default void configure(Helper helper) {
+        Boolean appMuted = optAppMuted();
+        if (appMuted != null) {
+            MobileAds.setAppMuted(appMuted);
+        }
+        Float appVolume = optAppVolume();
+        if (appVolume != null) {
+            MobileAds.setAppVolume(appVolume);
+        }
+        MobileAds.setRequestConfiguration(optRequestConfiguration());
+        helper.configForTestLab();
+        resolve();
+    }
+}

package/src/android/core/GenericAd.java

@@ -0,0 +1,22 @@
+package admob.plus.core;
+
+import static admob.plus.core.Helper.NOT_IMPLEMENTED;
+
+public interface GenericAd {
+    default boolean isLoaded() {
+        NOT_IMPLEMENTED();
+        return false;
+    }
+
+    default void load(Context ctx) {
+        NOT_IMPLEMENTED();
+    }
+
+    default void show(Context ctx) {
+        NOT_IMPLEMENTED();
+    }
+
+    default void hide(Context ctx) {
+        NOT_IMPLEMENTED();
+    }
+}

package/src/android/core/Helper.java

@@ -0,0 +1,134 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+
+import org.json.JSONArray;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Helper {
+    public static final SparseArray<Ad> ads = new SparseArray<Ad>();
+    private final Adapter adapter;
+
+    public Helper(Adapter adapter) {
+        this.adapter = adapter;
+    }
+
+    public static Ad getAd(Integer id) {
+        return ads.get(id);
+    }
+
+    public static double dpToPx(double dp) {
+        return dp * Resources.getSystem().getDisplayMetrics().density;
+    }
+
+    public static int pxToDp(int px) {
+        DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
+        int dp = Math.round(px / (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
+        return dp;
+    }
+
+    public static List<String> jsonArray2stringList(@Nullable JSONArray a) {
+        final List<String> result = new ArrayList<String>();
+        if (a == null) {
+            return result;
+        }
+        for (int i = 0; i < a.length(); i++) {
+            String testDeviceId = a.optString(i);
+            if (testDeviceId != null) {
+                result.add(testDeviceId);
+            }
+        }
+        return result;
+    }
+
+    @Nullable
+    public static ViewGroup getParentView(@Nullable View view) {
+        return view == null ? null : (ViewGroup) view.getParent();
+    }
+
+    @Nullable
+    public static ViewGroup removeFromParentView(@Nullable View view) {
+        ViewGroup viewParent = getParentView(view);
+        if (viewParent != null) viewParent.removeView(view);
+        return viewParent;
+    }
+
+    public static void NOT_IMPLEMENTED() {
+        throw new UnsupportedOperationException("Not implemented.");
+    }
+
+    private static String md5(String s) {
+        try {
+            MessageDigest digest = MessageDigest.getInstance("MD5");
+            digest.update(s.getBytes());
+            BigInteger bigInt = new BigInteger(1, digest.digest());
+            return String.format("%32s", bigInt.toString(16)).replace(' ', '0');
+        } catch (NoSuchAlgorithmException ignore) {
+        }
+        return "";
+    }
+
+    public Activity getActivity() {
+        return adapter.getActivity();
+    }
+
+    public boolean isRunningInTestLab() {
+        String testLabSetting = Settings.System.getString(getActivity().getContentResolver(), "firebase.test.lab");
+        return "true".equals(testLabSetting);
+    }
+
+    public void configForTestLab() {
+        if (!isRunningInTestLab()) {
+            return;
+        }
+        RequestConfiguration config = MobileAds.getRequestConfiguration();
+        List<String> testDeviceIds = config.getTestDeviceIds();
+
+        final String deviceId = getDeviceId();
+        if (testDeviceIds.contains(deviceId)) {
+            return;
+        }
+        testDeviceIds.add(deviceId);
+
+        RequestConfiguration.Builder builder = config.toBuilder();
+        builder.setTestDeviceIds(testDeviceIds);
+        MobileAds.setRequestConfiguration(builder.build());
+    }
+
+    @NonNull
+    private String getDeviceId() {
+        // This will request test ads on the emulator and device by passing this hashed device ID.
+        @SuppressLint("HardwareIds") String ANDROID_ID = Settings.Secure.getString(getActivity().getContentResolver(), Settings.Secure.ANDROID_ID);
+        return md5(ANDROID_ID).toUpperCase();
+    }
+
+    public interface Adapter {
+        Activity getActivity();
+
+        void emit(String eventName, Map<String, Object> data);
+
+        default void emit(String eventName) {
+            emit(eventName, new HashMap<>());
+        }
+    }
+}

package/src/browser/AdMobProxy.js

@@ -0,0 +1,33 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+'use strict';
+
+const AdMob = {
+  adCreate() {},
+  adHide() {},
+  adIsLoaded() {},
+  adLoad() {},
+  adShow() {},
+  bannerConfig() {},
+  bannerHide() {},
+  bannerLoad() {},
+  bannerShow() {},
+  configRequest() {},
+  configure() {},
+  interstitialIsLoaded() {},
+  interstitialLoad() {},
+  interstitialShow() {},
+  ready() {},
+  requestTrackingAuthorization() {},
+  rewardedInterstitialIsLoaded() {},
+  rewardedInterstitialLoad() {},
+  rewardedInterstitialShow() {},
+  rewardedIsLoaded() {},
+  rewardedLoad() {},
+  rewardedShow() {},
+  setAppMuted() {},
+  setAppVolume() {},
+  start() {},
+};
+
+// eslint-disable-next-line node/no-missing-require
+require('cordova/exec/proxy').add('AdMob', AdMob);