@javascriptcommon/react-native-google-mobile-ads 16.3.3

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

@@ -0,0 +1,293 @@
+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 android.app.Activity;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+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.WritableMap;
+import com.google.android.ump.ConsentDebugSettings;
+import com.google.android.ump.ConsentInformation;
+import com.google.android.ump.ConsentRequestParameters;
+import com.google.android.ump.UserMessagingPlatform;
+import io.invertase.googlemobileads.common.ReactNativeModule;
+import javax.annotation.Nonnull;
+
+public class ReactNativeGoogleMobileAdsConsentModule extends ReactNativeModule {
+
+  static final String NAME = "RNGoogleMobileAdsConsentModule";
+  private ConsentInformation consentInformation;
+
+  public ReactNativeGoogleMobileAdsConsentModule(ReactApplicationContext reactContext) {
+    super(reactContext, NAME);
+    consentInformation = UserMessagingPlatform.getConsentInformation(reactContext);
+  }
+
+  private String getConsentStatusString(int consentStatus) {
+    switch (consentStatus) {
+      case ConsentInformation.ConsentStatus.REQUIRED:
+        return "REQUIRED";
+      case ConsentInformation.ConsentStatus.NOT_REQUIRED:
+        return "NOT_REQUIRED";
+      case ConsentInformation.ConsentStatus.OBTAINED:
+        return "OBTAINED";
+      case ConsentInformation.ConsentStatus.UNKNOWN:
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  private String getPrivacyOptionsRequirementStatusString(
+      ConsentInformation.PrivacyOptionsRequirementStatus privacyOptionsRequirementStatus) {
+    switch (privacyOptionsRequirementStatus) {
+      case REQUIRED:
+        return "REQUIRED";
+      case NOT_REQUIRED:
+        return "NOT_REQUIRED";
+      case UNKNOWN:
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  private WritableMap getConsentInformation() {
+    WritableMap consentStatusMap = Arguments.createMap();
+    consentStatusMap.putString(
+        "status", getConsentStatusString(consentInformation.getConsentStatus()));
+    consentStatusMap.putBoolean("canRequestAds", consentInformation.canRequestAds());
+    consentStatusMap.putString(
+        "privacyOptionsRequirementStatus",
+        getPrivacyOptionsRequirementStatusString(
+            consentInformation.getPrivacyOptionsRequirementStatus()));
+    consentStatusMap.putBoolean(
+        "isConsentFormAvailable", consentInformation.isConsentFormAvailable());
+    return consentStatusMap;
+  }
+
+  @ReactMethod
+  public void requestInfoUpdate(@Nonnull final ReadableMap options, final Promise promise) {
+    try {
+      ConsentRequestParameters.Builder paramsBuilder = new ConsentRequestParameters.Builder();
+      ConsentDebugSettings.Builder debugSettingsBuilder =
+          new ConsentDebugSettings.Builder(getApplicationContext());
+
+      if (options.hasKey("testDeviceIdentifiers")) {
+        ReadableArray devices = options.getArray("testDeviceIdentifiers");
+
+        for (int i = 0; i < devices.size(); i++) {
+          debugSettingsBuilder.addTestDeviceHashedId(devices.getString(i));
+        }
+      }
+
+      if (options.hasKey("debugGeography")) {
+        debugSettingsBuilder.setDebugGeography(options.getInt("debugGeography"));
+      }
+
+      paramsBuilder.setConsentDebugSettings(debugSettingsBuilder.build());
+
+      if (options.hasKey("tagForUnderAgeOfConsent")) {
+        paramsBuilder.setTagForUnderAgeOfConsent(options.getBoolean("tagForUnderAgeOfConsent"));
+      }
+
+      ConsentRequestParameters consentRequestParameters = paramsBuilder.build();
+
+      Activity currentActivity = getCurrentActivity();
+
+      if (currentActivity == null) {
+        rejectPromiseWithCodeAndMessage(
+            promise,
+            "null-activity",
+            "Attempted to request a consent info update but the current Activity was null.");
+        return;
+      }
+
+      consentInformation.requestConsentInfoUpdate(
+          currentActivity,
+          consentRequestParameters,
+          () -> {
+            promise.resolve(getConsentInformation());
+          },
+          formError ->
+              rejectPromiseWithCodeAndMessage(
+                  promise, "consent-update-failed", formError.getMessage()));
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-update-failed", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void showForm(final Promise promise) {
+    try {
+      Activity currentActivity = getCurrentActivity();
+
+      if (currentActivity == null) {
+        rejectPromiseWithCodeAndMessage(
+            promise,
+            "null-activity",
+            "Consent form attempted to show but the current Activity was null.");
+        return;
+      }
+
+      currentActivity.runOnUiThread(
+          () ->
+              UserMessagingPlatform.loadConsentForm(
+                  getReactApplicationContext(),
+                  consentForm ->
+                      consentForm.show(
+                          currentActivity,
+                          formError -> {
+                            if (formError != null) {
+                              rejectPromiseWithCodeAndMessage(
+                                  promise, "consent-form-error", formError.getMessage());
+                            } else {
+                              promise.resolve(getConsentInformation());
+                            }
+                          }),
+                  formError ->
+                      rejectPromiseWithCodeAndMessage(
+                          promise, "consent-form-error", formError.getMessage())));
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-form-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void showPrivacyOptionsForm(final Promise promise) {
+    try {
+      Activity currentActivity = getCurrentActivity();
+
+      if (currentActivity == null) {
+        rejectPromiseWithCodeAndMessage(
+            promise,
+            "null-activity",
+            "Privacy options form attempted to show but the current Activity was null.");
+        return;
+      }
+
+      currentActivity.runOnUiThread(
+          () ->
+              UserMessagingPlatform.showPrivacyOptionsForm(
+                  currentActivity,
+                  formError -> {
+                    if (formError != null) {
+                      rejectPromiseWithCodeAndMessage(
+                          promise, "privacy-options-form-error", formError.getMessage());
+                    } else {
+                      promise.resolve(getConsentInformation());
+                    }
+                  }));
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-form-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void loadAndShowConsentFormIfRequired(final Promise promise) {
+    try {
+      Activity currentActivity = getCurrentActivity();
+
+      if (currentActivity == null) {
+        rejectPromiseWithCodeAndMessage(
+            promise,
+            "null-activity",
+            "Consent form attempted to load and show if required but the current Activity was"
+                + " null.");
+        return;
+      }
+
+      currentActivity.runOnUiThread(
+          () ->
+              UserMessagingPlatform.loadAndShowConsentFormIfRequired(
+                  currentActivity,
+                  formError -> {
+                    if (formError != null) {
+                      rejectPromiseWithCodeAndMessage(
+                          promise, "consent-form-error", formError.getMessage());
+                    } else {
+                      promise.resolve(getConsentInformation());
+                    }
+                  }));
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-form-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void getConsentInfo(Promise promise) {
+    promise.resolve(getConsentInformation());
+  }
+
+  @ReactMethod
+  public void reset() {
+    consentInformation.reset();
+  }
+
+  @ReactMethod
+  public void getTCString(Promise promise) {
+    try {
+      SharedPreferences prefs =
+          PreferenceManager.getDefaultSharedPreferences(getReactApplicationContext());
+      // https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20CMP%20API%20v2.md#in-app-details
+      String tcString = prefs.getString("IABTCF_TCString", null);
+      promise.resolve(tcString);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-string-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void getGdprApplies(Promise promise) {
+    try {
+      SharedPreferences prefs =
+          PreferenceManager.getDefaultSharedPreferences(getReactApplicationContext());
+      int gdprApplies = prefs.getInt("IABTCF_gdprApplies", 0);
+      promise.resolve(gdprApplies == 1);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-string-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void getPurposeConsents(Promise promise) {
+    try {
+      SharedPreferences prefs =
+          PreferenceManager.getDefaultSharedPreferences(getReactApplicationContext());
+      String purposeConsents = prefs.getString("IABTCF_PurposeConsents", "");
+      promise.resolve(purposeConsents);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-string-error", e.toString());
+    }
+  }
+
+  @ReactMethod
+  public void getPurposeLegitimateInterests(Promise promise) {
+    try {
+      SharedPreferences prefs =
+          PreferenceManager.getDefaultSharedPreferences(getReactApplicationContext());
+      String purposeLegitimateInterests = prefs.getString("IABTCF_PurposeLegitimateInterests", "");
+      promise.resolve(purposeLegitimateInterests);
+    } catch (Exception e) {
+      rejectPromiseWithCodeAndMessage(promise, "consent-string-error", e.toString());
+    }
+  }
+}

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

@@ -0,0 +1,76 @@
+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_REWARDED_INTERSTITIAL =
+      "google_mobile_ads_rewarded_interstitial_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_PAID = "paid";
+  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_APP_EVENT = "app_event";
+
+  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/ReactNativeGoogleMobileAdsFullScreenAdModule.kt

@@ -0,0 +1,201 @@
+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.
+ *
+ */
+
+// Migrated to the GMA Next-Gen SDK (Android). AdMob-only: only Interstitial and App Open
+// full-screen formats are supported in this fork (Rewarded / RewardedInterstitial / Ad Manager
+// were removed). iOS keeps using the classic SDK unchanged.
+
+import android.app.Activity
+import android.util.Log
+import android.util.SparseArray
+import com.facebook.react.bridge.*
+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.LoadAdError
+import io.invertase.googlemobileads.common.ReactNativeModule
+
+abstract class ReactNativeGoogleMobileAdsFullScreenAdModule<T>(
+  reactContext: ReactApplicationContext?,
+  moduleName: String
+) : ReactNativeModule(reactContext, moduleName) {
+  private val adArray = SparseArray<T>()
+
+  abstract fun getAdEventName(): String
+
+  /** Next-Gen load is a static call on the ad type; the subclass routes it. */
+  abstract fun loadAd(adRequest: AdRequest, adLoadCallback: AdLoadCallback<T>)
+
+  /** Subclass attaches the typed Next-Gen ad-event callback, delegating to the dispatch helpers. */
+  abstract fun attachAdEventCallback(ad: T, requestId: Int, adUnitId: String)
+
+  /**
+   * Subclass shows the ad (immersive mode + show). requestId/adUnitId are passed through so formats
+   * that emit show-time events (e.g. Rewarded's earned-reward callback) can dispatch them.
+   */
+  abstract fun showAd(
+    ad: T,
+    activity: Activity,
+    immersiveModeEnabled: Boolean,
+    requestId: Int,
+    adUnitId: String
+  )
+
+  protected fun dispatchFullScreenEvent(type: String, requestId: Int, adUnitId: String) {
+    ReactNativeGoogleMobileAdsCommon.sendAdEvent(getAdEventName(), requestId, type, adUnitId, null)
+  }
+
+  /** Dispatch a typed event carrying a data payload (e.g. the reward item). */
+  protected fun dispatchFullScreenEventWithData(
+    type: String,
+    requestId: Int,
+    adUnitId: String,
+    data: WritableMap
+  ) {
+    ReactNativeGoogleMobileAdsCommon.sendAdEvent(getAdEventName(), requestId, type, adUnitId, null, data)
+  }
+
+  protected fun dispatchPaidEvent(requestId: Int, adUnitId: String, adValue: AdValue) {
+    val payload = Arguments.createMap()
+    payload.putDouble("value", 1e-6 * adValue.valueMicros)
+    payload.putDouble("precision", adValue.precisionType.ordinal.toDouble())
+    payload.putString("currency", adValue.currencyCode)
+    sendAdEvent(
+      ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_PAID,
+      requestId,
+      adUnitId,
+      null,
+      payload
+    )
+  }
+
+  private fun sendAdEvent(
+    type: String,
+    requestId: Int,
+    adUnitId: String,
+    error: WritableMap?,
+    data: WritableMap?
+  ) {
+    ReactNativeGoogleMobileAdsCommon.sendAdEvent(
+      getAdEventName(),
+      requestId,
+      type,
+      adUnitId,
+      error,
+      data
+    )
+  }
+
+  fun load(requestId: Int, adUnitId: String, adRequestOptions: ReadableMap) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      val error = Arguments.createMap()
+      error.putString("code", "null-activity")
+      error.putString("message", "Ad attempted to load but the current Activity was null.")
+      sendAdEvent(
+        ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR,
+        requestId,
+        adUnitId,
+        error,
+        null
+      )
+      return
+    }
+    val builder = AdRequest.Builder(adUnitId)
+    ReactNativeGoogleMobileAdsCommon.applyRequestOptions(builder, adRequestOptions)
+    val adRequest = builder.build()
+    val adLoadCallback = AdLoadCallbackImpl(requestId, adUnitId)
+    activity.runOnUiThread { loadAd(adRequest, adLoadCallback) }
+  }
+
+  fun show(requestId: Int, adUnitId: String, showOptions: ReadableMap, promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      rejectPromiseWithCodeAndMessage(
+        promise,
+        "null-activity",
+        "Ad attempted to show but the current Activity was null."
+      )
+      return
+    }
+    activity.runOnUiThread {
+      val ad = adArray[requestId]
+      if (ad == null) {
+        rejectPromiseWithCodeAndMessage(
+          promise,
+          "null-ad",
+          "Ad attempted to show but it has not loaded."
+        )
+        return@runOnUiThread
+      }
+      var immersiveModeEnabled = false
+      if (showOptions.hasKey("immersiveModeEnabled")) {
+        immersiveModeEnabled = showOptions.getBoolean("immersiveModeEnabled")
+      }
+      showAd(ad, activity, immersiveModeEnabled, requestId, adUnitId)
+      promise.resolve(null)
+    }
+  }
+
+  inner class AdLoadCallbackImpl(
+    private val requestId: Int,
+    private val adUnitId: String
+  ) : AdLoadCallback<T> {
+    override fun onAdLoaded(ad: T) {
+      try {
+        adArray.put(requestId, ad)
+        attachAdEventCallback(ad, requestId, adUnitId)
+        sendAdEvent(
+          ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_LOADED,
+          requestId,
+          adUnitId,
+          null,
+          null
+        )
+      } catch (e: Exception) {
+        Log.w("RNGoogleMobileAds", "Unknown error on load", e)
+        val error = Arguments.createMap()
+        error.putString("code", "internal")
+        error.putString("message", e.message)
+        sendAdEvent(
+          ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR,
+          requestId,
+          adUnitId,
+          error,
+          null
+        )
+      }
+    }
+
+    override fun onAdFailedToLoad(loadAdError: LoadAdError) {
+      val error = Arguments.createMap()
+      val codeAndMessage =
+        ReactNativeGoogleMobileAdsCommon.getCodeAndMessageFromAdError(loadAdError)
+      error.putString("code", codeAndMessage[0])
+      error.putString("message", codeAndMessage[1])
+      sendAdEvent(
+        ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_ERROR,
+        requestId,
+        adUnitId,
+        error,
+        null
+      )
+    }
+  }
+}

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

@@ -0,0 +1,92 @@
+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 android.app.Activity
+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.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.interstitial.InterstitialAd
+import com.google.android.libraries.ads.mobile.sdk.interstitial.InterstitialAdEventCallback
+
+class ReactNativeGoogleMobileAdsInterstitialModule(reactContext: ReactApplicationContext?) :
+  ReactNativeGoogleMobileAdsFullScreenAdModule<InterstitialAd>(reactContext, NAME) {
+
+  override fun getAdEventName(): String {
+    return ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_INTERSTITIAL
+  }
+
+  @ReactMethod
+  fun interstitialLoad(requestId: Int, adUnitId: String, adRequestOptions: ReadableMap) {
+    load(requestId, adUnitId, adRequestOptions)
+  }
+
+  @ReactMethod
+  fun interstitialShow(
+    requestId: Int, adUnitId: String, showOptions: ReadableMap, promise: Promise
+  ) {
+    show(requestId, adUnitId, showOptions, promise)
+  }
+
+  override fun loadAd(adRequest: AdRequest, adLoadCallback: AdLoadCallback<InterstitialAd>) {
+    InterstitialAd.load(adRequest, adLoadCallback)
+  }
+
+  override fun attachAdEventCallback(ad: InterstitialAd, requestId: Int, adUnitId: String) {
+    ad.adEventCallback =
+      object : InterstitialAdEventCallback {
+        override fun onAdShowedFullScreenContent() {
+          dispatchFullScreenEvent(
+            ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_OPENED, requestId, adUnitId)
+        }
+
+        override fun onAdDismissedFullScreenContent() {
+          dispatchFullScreenEvent(
+            ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLOSED, requestId, adUnitId)
+        }
+
+        override fun onAdClicked() {
+          dispatchFullScreenEvent(
+            ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_CLICKED, requestId, adUnitId)
+        }
+
+        override fun onAdPaid(adValue: AdValue) {
+          dispatchPaidEvent(requestId, adUnitId, adValue)
+        }
+      }
+  }
+
+  override fun showAd(
+    ad: InterstitialAd,
+    activity: Activity,
+    immersiveModeEnabled: Boolean,
+    requestId: Int,
+    adUnitId: String
+  ) {
+    ad.setImmersiveMode(immersiveModeEnabled)
+    ad.show(activity)
+  }
+
+  companion object {
+    const val NAME = "RNGoogleMobileAdsInterstitialModule"
+  }
+}