react-native-google-mobile-ads 4.1.0

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsConsentModule.java

@@ -0,0 +1,226 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.google.ads.consent.AdProvider;
+import com.google.ads.consent.ConsentForm;
+import com.google.ads.consent.ConsentFormListener;
+import com.google.ads.consent.ConsentInfoUpdateListener;
+import com.google.ads.consent.ConsentInformation;
+import com.google.ads.consent.ConsentStatus;
+import com.google.ads.consent.DebugGeography;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.List;
+
+public class ReactNativeGoogleMobileAdsConsentModule extends ReactNativeModule {
+  private static final String TAG = "RNGoogleMobileAdsConsentModule";
+  private ConsentInformation consentInformation;
+  private ConsentForm consentForm;
+
+  public ReactNativeGoogleMobileAdsConsentModule(ReactApplicationContext reactContext) {
+    super(reactContext, TAG);
+    consentInformation = ConsentInformation.getInstance(reactContext);
+  }
+
+  private int getConsentStatusInt(ConsentStatus consentStatus) {
+    switch (consentStatus) {
+      case NON_PERSONALIZED:
+        return 1;
+      case PERSONALIZED:
+        return 2;
+      case UNKNOWN:
+      default:
+        return 0;
+    }
+  }
+
+  @ReactMethod
+  public void requestInfoUpdate(ReadableArray publisherIds, Promise promise) {
+    @SuppressWarnings("SuspiciousToArrayCall")
+    String[] publisherIdsArray = publisherIds.toArrayList().toArray(new String[0]);
+
+    consentInformation.requestConsentInfoUpdate(
+        publisherIdsArray,
+        new ConsentInfoUpdateListener() {
+          @Override
+          public void onConsentInfoUpdated(ConsentStatus consentStatus) {
+            WritableMap requestInfoMap = Arguments.createMap();
+            requestInfoMap.putInt("status", getConsentStatusInt(consentStatus));
+            requestInfoMap.putBoolean(
+                "isRequestLocationInEeaOrUnknown",
+                consentInformation.isRequestLocationInEeaOrUnknown());
+            promise.resolve(requestInfoMap);
+          }
+
+          @Override
+          public void onFailedToUpdateConsentInfo(String reason) {
+            rejectPromiseWithCodeAndMessage(promise, "consent-update-failed", reason);
+          }
+        });
+  }
+
+  @ReactMethod
+  public void showForm(ReadableMap options, Promise promise) {
+    if (getCurrentActivity() == null) {
+      rejectPromiseWithCodeAndMessage(
+          promise,
+          "null-activity",
+          "Consent form attempted to show but the current Activity was null.");
+      return;
+    }
+    getCurrentActivity()
+        .runOnUiThread(
+            () -> {
+              URL privacyUrl = null;
+
+              try {
+                privacyUrl = new URL(options.getString("privacyPolicy"));
+              } catch (MalformedURLException e) {
+                // Validated in JS land
+              }
+
+              ConsentFormListener listener =
+                  new ConsentFormListener() {
+                    @Override
+                    public void onConsentFormLoaded() {
+                      try {
+                        consentForm.show();
+                      } catch (Exception e) {
+                        rejectPromiseWithCodeAndMessage(
+                            promise, "consent-form-error", e.toString());
+                      }
+                    }
+
+                    @Override
+                    public void onConsentFormClosed(
+                        ConsentStatus consentStatus, Boolean userPrefersAdFree) {
+                      WritableMap consentFormMap = Arguments.createMap();
+                      consentFormMap.putInt("status", getConsentStatusInt(consentStatus));
+                      consentFormMap.putBoolean("userPrefersAdFree", userPrefersAdFree);
+                      promise.resolve(consentFormMap);
+                    }
+
+                    @Override
+                    public void onConsentFormError(String reason) {
+                      rejectPromiseWithCodeAndMessage(promise, "consent-form-error", reason);
+                    }
+                  };
+
+              ConsentForm.Builder builder =
+                  new ConsentForm.Builder(getCurrentActivity(), privacyUrl).withListener(listener);
+
+              if (options.hasKey("withPersonalizedAds")
+                  && options.getBoolean("withPersonalizedAds")) {
+                builder = builder.withPersonalizedAdsOption();
+              }
+
+              if (options.hasKey("withNonPersonalizedAds")
+                  && options.getBoolean("withNonPersonalizedAds")) {
+                builder = builder.withNonPersonalizedAdsOption();
+              }
+
+              if (options.hasKey("withAdFree") && options.getBoolean("withAdFree")) {
+                builder = builder.withAdFreeOption();
+              }
+
+              consentForm = builder.build();
+              consentForm.load();
+            });
+  }
+
+  @ReactMethod
+  public void getStatus(Promise promise) {
+    ConsentStatus status = consentInformation.getConsentStatus();
+    promise.resolve(getConsentStatusInt(status));
+  }
+
+  @ReactMethod
+  public void setStatus(int status, Promise promise) {
+    ConsentStatus consentStatus = ConsentStatus.UNKNOWN;
+
+    switch (status) {
+      case 0:
+        consentStatus = ConsentStatus.UNKNOWN;
+        break;
+      case 1:
+        consentStatus = ConsentStatus.NON_PERSONALIZED;
+        break;
+      case 2:
+        consentStatus = ConsentStatus.PERSONALIZED;
+        break;
+    }
+
+    consentInformation.setConsentStatus(consentStatus);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void getAdProviders(Promise promise) {
+    List<AdProvider> providers = consentInformation.getAdProviders();
+
+    WritableArray formattedAdProviders = Arguments.createArray();
+
+    for (AdProvider provider : providers) {
+      WritableMap formattedProvider = Arguments.createMap();
+      formattedProvider.putString("companyName", provider.getName());
+      formattedProvider.putString("companyId", provider.getId());
+      formattedProvider.putString("privacyPolicyUrl", provider.getPrivacyPolicyUrlString());
+      formattedAdProviders.pushMap(formattedProvider);
+    }
+
+    promise.resolve(formattedAdProviders);
+  }
+
+  @ReactMethod
+  public void setTagForUnderAgeOfConsent(boolean tag, Promise promise) {
+    consentInformation.setTagForUnderAgeOfConsent(tag);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void setDebugGeography(int geography, Promise promise) {
+    if (geography == 0) {
+      consentInformation.setDebugGeography(DebugGeography.DEBUG_GEOGRAPHY_DISABLED);
+    } else if (geography == 1) {
+      consentInformation.setDebugGeography(DebugGeography.DEBUG_GEOGRAPHY_EEA);
+    } else if (geography == 2) {
+      consentInformation.setDebugGeography(DebugGeography.DEBUG_GEOGRAPHY_NOT_EEA);
+    }
+
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void addTestDevices(ReadableArray deviceIds, Promise promise) {
+    List<Object> devices = deviceIds.toArrayList();
+    for (Object device : devices) {
+      consentInformation.addTestDevice((String) device);
+    }
+    promise.resolve(null);
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsEvent.java

@@ -0,0 +1,72 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import io.invertase.googlemobileads.interfaces.NativeEvent;
+
+public class ReactNativeGoogleMobileAdsEvent implements NativeEvent {
+  public static final String GOOGLE_MOBILE_ADS_EVENT_APP_OPEN = "google_mobile_ads_app_open_event";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_INTERSTITIAL =
+      "google_mobile_ads_interstitial_event";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_REWARDED = "google_mobile_ads_rewarded_event";
+
+  public static final String GOOGLE_MOBILE_ADS_EVENT_LOADED = "loaded";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_ERROR = "error";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_OPENED = "opened";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_CLICKED = "clicked";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_CLOSED = "closed";
+
+  public static final String GOOGLE_MOBILE_ADS_EVENT_REWARDED_LOADED = "rewarded_loaded";
+  public static final String GOOGLE_MOBILE_ADS_EVENT_REWARDED_EARNED_REWARD =
+      "rewarded_earned_reward";
+
+  private static final String KEY_BODY = "body";
+  private static final String KEY_REQUEST_ID = "requestId";
+  private static final String KEY_GOOGLE_MOBILE_ADS_EVENT_UNIT_ID = "adUnitId";
+  private static final String KEY_EVENT_NAME = "eventName";
+
+  private String eventName;
+  private int requestId;
+  private String adUnitId;
+  private WritableMap eventBody;
+
+  public ReactNativeGoogleMobileAdsEvent(
+      String eventName, int requestId, String adUnitId, WritableMap eventBody) {
+    this.eventName = eventName;
+    this.requestId = requestId;
+    this.adUnitId = adUnitId;
+    this.eventBody = eventBody;
+  }
+
+  @Override
+  public String getEventName() {
+    return eventName;
+  }
+
+  @Override
+  public WritableMap getEventBody() {
+    WritableMap event = Arguments.createMap();
+    event.putMap(KEY_BODY, eventBody);
+    event.putInt(KEY_REQUEST_ID, requestId);
+    event.putString(KEY_GOOGLE_MOBILE_ADS_EVENT_UNIT_ID, adUnitId);
+    event.putString(KEY_EVENT_NAME, eventName);
+    return event;
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsInterstitialModule.java

@@ -0,0 +1,159 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.getCodeAndMessageFromAdError;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsCommon.sendAdEvent;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLICKED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLOSED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_INTERSTITIAL;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_LOADED;
+import static io.invertase.googlemobileads.ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_OPENED;
+
+import android.app.Activity;
+import android.util.SparseArray;
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+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.interstitial.InterstitialAd;
+import com.google.android.gms.ads.interstitial.InterstitialAdLoadCallback;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+import javax.annotation.Nullable;
+
+public class ReactNativeGoogleMobileAdsInterstitialModule extends ReactNativeModule {
+  private static final String SERVICE = "RNGoogleMobileAdsInterstitialModule";
+  private static SparseArray<InterstitialAd> interstitialAdArray = new SparseArray<>();
+
+  public ReactNativeGoogleMobileAdsInterstitialModule(ReactApplicationContext reactContext) {
+    super(reactContext, SERVICE);
+  }
+
+  private void sendInterstitialEvent(
+      String type, int requestId, String adUnitId, @Nullable WritableMap error) {
+    sendAdEvent(GOOGLE_MOBILE_ADS_EVENT_INTERSTITIAL, requestId, type, adUnitId, error);
+  }
+
+  @ReactMethod
+  public void interstitialLoad(int requestId, String adUnitId, ReadableMap adRequestOptions) {
+    Activity currentActivity = getCurrentActivity();
+    if (currentActivity == null) {
+      WritableMap error = Arguments.createMap();
+      error.putString("code", "null-activity");
+      error.putString(
+          "message", "Interstitial ad attempted to load but the current Activity was null.");
+      sendInterstitialEvent(GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error);
+      return;
+    }
+    currentActivity.runOnUiThread(
+        () -> {
+          AdRequest.Builder adRequestBuilder = new AdRequest.Builder();
+          AdRequest adRequest = adRequestBuilder.build();
+
+          InterstitialAdLoadCallback interstitialAdLoadCallback =
+              new InterstitialAdLoadCallback() {
+
+                @Override
+                public void onAdLoaded(@NonNull InterstitialAd interstitialAd) {
+
+                  interstitialAd.setFullScreenContentCallback(
+                      new FullScreenContentCallback() {
+                        @Override
+                        public void onAdDismissedFullScreenContent() {
+                          sendInterstitialEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_CLOSED, requestId, adUnitId, null);
+                          interstitialAdArray.put(requestId, null);
+                        }
+
+                        @Override
+                        public void onAdClicked() {
+                          sendInterstitialEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_CLICKED, requestId, adUnitId, null);
+                        }
+
+                        @Override
+                        public void onAdShowedFullScreenContent() {
+                          sendInterstitialEvent(
+                              GOOGLE_MOBILE_ADS_EVENT_OPENED, requestId, adUnitId, null);
+                        }
+                      });
+
+                  interstitialAdArray.put(requestId, interstitialAd);
+                  sendInterstitialEvent(GOOGLE_MOBILE_ADS_EVENT_LOADED, requestId, adUnitId, null);
+                }
+
+                @Override
+                public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+                  WritableMap error = Arguments.createMap();
+                  String[] codeAndMessage = getCodeAndMessageFromAdError(loadAdError);
+                  error.putString("code", codeAndMessage[0]);
+                  error.putString("message", codeAndMessage[1]);
+                  sendInterstitialEvent(GOOGLE_MOBILE_ADS_EVENT_ERROR, requestId, adUnitId, error);
+                }
+              };
+
+          InterstitialAd.load(currentActivity, adUnitId, adRequest, interstitialAdLoadCallback);
+        });
+  }
+
+  @ReactMethod
+  public void interstitialShow(int requestId, ReadableMap showOptions, Promise promise) {
+    if (getCurrentActivity() == null) {
+      rejectPromiseWithCodeAndMessage(
+          promise,
+          "null-activity",
+          "Interstitial ad attempted to show but the current Activity was null.");
+      return;
+    }
+    getCurrentActivity()
+        .runOnUiThread(
+            () -> {
+              InterstitialAd interstitialAd = interstitialAdArray.get(requestId);
+              if (interstitialAd == null) {
+                rejectPromiseWithCodeAndMessage(
+                    promise,
+                    "null-interstitialAd",
+                    "Interstitial ad attempted to show but its object was null.");
+                return;
+              }
+
+              if (showOptions.hasKey("immersiveModeEnabled")) {
+                interstitialAd.setImmersiveMode(showOptions.getBoolean("immersiveModeEnabled"));
+              } else {
+                interstitialAd.setImmersiveMode(false);
+              }
+
+              String a = String.valueOf(requestId);
+
+              if (interstitialAd != null) {
+                interstitialAd.show(getCurrentActivity());
+                promise.resolve(null);
+              } else {
+                rejectPromiseWithCodeAndMessage(
+                    promise, "not-ready", "Interstitial ad attempted to show but was not ready.");
+              }
+            });
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsModule.java

@@ -0,0 +1,143 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.google.android.gms.ads.AdRequest;
+import com.google.android.gms.ads.MobileAds;
+import com.google.android.gms.ads.RequestConfiguration;
+import com.google.android.gms.ads.initialization.AdapterStatus;
+import com.google.android.gms.ads.initialization.InitializationStatus;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class ReactNativeGoogleMobileAdsModule extends ReactNativeModule {
+  private static final String SERVICE = "RNGoogleMobileAdsModule";
+
+  ReactNativeGoogleMobileAdsModule(ReactApplicationContext reactContext) {
+    super(reactContext, SERVICE);
+  }
+
+  private RequestConfiguration buildRequestConfiguration(ReadableMap requestConfiguration) {
+    RequestConfiguration.Builder builder = new RequestConfiguration.Builder();
+
+    if (requestConfiguration.hasKey("testDeviceIdentifiers")) {
+      ArrayList<Object> devices =
+          Objects.requireNonNull(requestConfiguration.getArray("testDeviceIdentifiers"))
+              .toArrayList();
+
+      List<String> testDeviceIds = new ArrayList<>();
+
+      for (Object device : devices) {
+        String id = (String) device;
+
+        if (id.equals("EMULATOR")) {
+          testDeviceIds.add(AdRequest.DEVICE_ID_EMULATOR);
+        } else {
+          testDeviceIds.add(id);
+        }
+      }
+      builder.setTestDeviceIds(testDeviceIds);
+    }
+
+    if (requestConfiguration.hasKey("maxAdContentRating")) {
+      String rating = requestConfiguration.getString("maxAdContentRating");
+
+      switch (Objects.requireNonNull(rating)) {
+        case "G":
+          builder.setMaxAdContentRating(RequestConfiguration.MAX_AD_CONTENT_RATING_G);
+          break;
+        case "PG":
+          builder.setMaxAdContentRating(RequestConfiguration.MAX_AD_CONTENT_RATING_PG);
+          break;
+        case "T":
+          builder.setMaxAdContentRating(RequestConfiguration.MAX_AD_CONTENT_RATING_T);
+          break;
+        case "MA":
+          builder.setMaxAdContentRating(RequestConfiguration.MAX_AD_CONTENT_RATING_MA);
+          break;
+      }
+    }
+
+    if (requestConfiguration.hasKey("tagForChildDirectedTreatment")) {
+      boolean tagForChildDirectedTreatment =
+          requestConfiguration.getBoolean("tagForChildDirectedTreatment");
+      if (tagForChildDirectedTreatment) {
+        builder.setTagForChildDirectedTreatment(
+            RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_TRUE);
+      } else {
+        builder.setTagForChildDirectedTreatment(
+            RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_FALSE);
+      }
+    } else {
+      builder.setTagForChildDirectedTreatment(
+          RequestConfiguration.TAG_FOR_CHILD_DIRECTED_TREATMENT_UNSPECIFIED);
+    }
+
+    if (requestConfiguration.hasKey("tagForUnderAgeOfConsent")) {
+      boolean tagForUnderAgeOfConsent = requestConfiguration.getBoolean("tagForUnderAgeOfConsent");
+      if (tagForUnderAgeOfConsent) {
+        builder.setTagForUnderAgeOfConsent(RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_TRUE);
+      } else {
+        builder.setTagForUnderAgeOfConsent(RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_FALSE);
+      }
+    } else {
+      builder.setTagForUnderAgeOfConsent(
+          RequestConfiguration.TAG_FOR_UNDER_AGE_OF_CONSENT_UNSPECIFIED);
+    }
+
+    return builder.build();
+  }
+
+  @ReactMethod
+  public void initialize(Promise promise) {
+    MobileAds.initialize(
+        getContext(),
+        new OnInitializationCompleteListener() {
+          @Override
+          public void onInitializationComplete(InitializationStatus initializationStatus) {
+            WritableArray result = Arguments.createArray();
+            for (Map.Entry<String, AdapterStatus> entry :
+                initializationStatus.getAdapterStatusMap().entrySet()) {
+              WritableMap info = Arguments.createMap();
+              info.putString("name", entry.getKey());
+              info.putInt("state", entry.getValue().getInitializationState().ordinal());
+              info.putString("description", entry.getValue().getDescription());
+              result.pushMap(info);
+            }
+            promise.resolve(result);
+          }
+        });
+  }
+
+  @ReactMethod
+  public void setRequestConfiguration(ReadableMap requestConfiguration, Promise promise) {
+    MobileAds.setRequestConfiguration(buildRequestConfiguration(requestConfiguration));
+    promise.resolve(null);
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsPackage.java

@@ -0,0 +1,48 @@
+package io.invertase.googlemobileads;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+@SuppressWarnings("unused")
+public class ReactNativeGoogleMobileAdsPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReactNativeAppModule(reactContext));
+    modules.add(new ReactNativeGoogleMobileAdsModule(reactContext));
+    modules.add(new ReactNativeGoogleMobileAdsConsentModule(reactContext));
+    modules.add(new ReactNativeGoogleMobileAdsAppOpenModule(reactContext));
+    modules.add(new ReactNativeGoogleMobileAdsInterstitialModule(reactContext));
+    modules.add(new ReactNativeGoogleMobileAdsRewardedModule(reactContext));
+    return modules;
+  }
+
+  @Nonnull
+  @Override
+  public List<ViewManager> createViewManagers(@Nonnull ReactApplicationContext reactContext) {
+    return Arrays.asList(new ReactNativeGoogleMobileAdsBannerAdViewManager());
+  }
+}