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

package/android/src/main/java/io/invertase/googlemobileads/ReactNativeGoogleMobileAdsAppOpenModule.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.appopen.AppOpenAd
+import com.google.android.libraries.ads.mobile.sdk.appopen.AppOpenAdEventCallback
+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
+
+class ReactNativeGoogleMobileAdsAppOpenModule(reactContext: ReactApplicationContext?) :
+  ReactNativeGoogleMobileAdsFullScreenAdModule<AppOpenAd>(reactContext, NAME) {
+
+  override fun getAdEventName(): String {
+    return ReactNativeGoogleMobileAdsEvent.GOOGLE_MOBILE_ADS_EVENT_APP_OPEN
+  }
+
+  @ReactMethod
+  fun appOpenLoad(requestId: Int, adUnitId: String, adRequestOptions: ReadableMap) {
+    load(requestId, adUnitId, adRequestOptions)
+  }
+
+  @ReactMethod
+  fun appOpenShow(
+    requestId: Int, adUnitId: String, showOptions: ReadableMap, promise: Promise
+  ) {
+    show(requestId, adUnitId, showOptions, promise)
+  }
+
+  override fun loadAd(adRequest: AdRequest, adLoadCallback: AdLoadCallback<AppOpenAd>) {
+    AppOpenAd.load(adRequest, adLoadCallback)
+  }
+
+  override fun attachAdEventCallback(ad: AppOpenAd, requestId: Int, adUnitId: String) {
+    ad.adEventCallback =
+      object : AppOpenAdEventCallback {
+        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: AppOpenAd,
+    activity: Activity,
+    immersiveModeEnabled: Boolean,
+    requestId: Int,
+    adUnitId: String
+  ) {
+    ad.setImmersiveMode(immersiveModeEnabled)
+    ad.show(activity)
+  }
+
+  companion object {
+    const val NAME = "RNGoogleMobileAdsAppOpenModule"
+  }
+}

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

@@ -0,0 +1,303 @@
+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 (com.google.android.libraries.ads.mobile.sdk) on Android.
+// Ad Manager / GAM paths are dropped: this app serves plain AdMob banners only. iOS is unchanged.
+
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.google.android.libraries.ads.mobile.sdk.banner.AdSize;
+import com.google.android.libraries.ads.mobile.sdk.banner.AdView;
+import com.google.android.libraries.ads.mobile.sdk.banner.BannerAd;
+import com.google.android.libraries.ads.mobile.sdk.banner.BannerAdEventCallback;
+import com.google.android.libraries.ads.mobile.sdk.banner.BannerAdRequest;
+import com.google.android.libraries.ads.mobile.sdk.common.AdLoadCallback;
+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.ReactNativeAdView;
+import io.invertase.googlemobileads.common.SharedUtils;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class ReactNativeGoogleMobileAdsBannerAdViewManager
+    extends SimpleViewManager<ReactNativeAdView> {
+  private static final String REACT_CLASS = "RNGoogleMobileAdsBannerView";
+  private final String EVENT_AD_LOADED = "onAdLoaded";
+  private final String EVENT_AD_IMPRESSION = "onAdImpression";
+  private final String EVENT_AD_CLICKED = "onAdClicked";
+  private final String EVENT_AD_FAILED_TO_LOAD = "onAdFailedToLoad";
+  private final String EVENT_AD_OPENED = "onAdOpened";
+  private final String EVENT_AD_CLOSED = "onAdClosed";
+  private final String EVENT_PAID = "onPaid";
+  private final String EVENT_SIZE_CHANGE = "onSizeChange";
+  private final String COMMAND_ID_RECORD_MANUAL_IMPRESSION = "recordManualImpression";
+  private final String COMMAND_ID_LOAD = "load";
+
+  @Nonnull
+  @Override
+  public String getName() {
+    return REACT_CLASS;
+  }
+
+  @Nonnull
+  @Override
+  public ReactNativeAdView createViewInstance(@Nonnull ThemedReactContext themedReactContext) {
+    return new ReactNativeAdView(themedReactContext);
+  }
+
+  @Override
+  public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+    MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+    builder.put(OnNativeEvent.EVENT_NAME, MapBuilder.of("registrationName", "onNativeEvent"));
+    return builder.build();
+  }
+
+  @Override
+  public void receiveCommand(
+      @NonNull ReactNativeAdView reactViewGroup, String commandId, @Nullable ReadableArray args) {
+    super.receiveCommand(reactViewGroup, commandId, args);
+
+    AdView adView = getAdView(reactViewGroup);
+
+    if (commandId.equals(COMMAND_ID_RECORD_MANUAL_IMPRESSION)) {
+      if (adView != null) {
+        BannerAd bannerAd = adView.getBannerAd();
+        if (bannerAd != null) {
+          bannerAd.recordManualImpression();
+        }
+      }
+    } else if (commandId.equals(COMMAND_ID_LOAD)) {
+      requestAd(reactViewGroup);
+    }
+  }
+
+  @ReactProp(name = "unitId")
+  public void setUnitId(ReactNativeAdView reactViewGroup, String value) {
+    reactViewGroup.setUnitId(value);
+    reactViewGroup.setPropsChanged(true);
+  }
+
+  @ReactProp(name = "request")
+  public void setRequest(ReactNativeAdView reactViewGroup, String value) {
+    try {
+      JSONObject jsonObject = new JSONObject(value);
+      WritableMap writableMap = SharedUtils.jsonObjectToWritableMap(jsonObject);
+      reactViewGroup.setRequestOptions(writableMap);
+      reactViewGroup.setPropsChanged(true);
+    } catch (JSONException e) {
+      e.printStackTrace();
+    }
+  }
+
+  @ReactProp(name = "sizeConfig")
+  public void setSizeConfig(ReactNativeAdView reactViewGroup, ReadableMap sizeConfig) {
+    if (sizeConfig != null) {
+      if (sizeConfig.hasKey("maxHeight") && !sizeConfig.isNull("maxHeight")) {
+        reactViewGroup.setMaxAdHeight((float) sizeConfig.getDouble("maxHeight"));
+      } else {
+        reactViewGroup.setMaxAdHeight(0);
+      }
+
+      if (sizeConfig.hasKey("width") && !sizeConfig.isNull("width")) {
+        reactViewGroup.setAdWidth((float) sizeConfig.getDouble("width"));
+      } else {
+        reactViewGroup.setAdWidth(0);
+      }
+
+      if (sizeConfig.hasKey("sizes") && !sizeConfig.isNull("sizes")) {
+        ReadableArray sizesArray = sizeConfig.getArray("sizes");
+        if (sizesArray != null) {
+          List<AdSize> sizeList = new ArrayList<>();
+          for (int i = 0; i < sizesArray.size(); i++) {
+            if (sizesArray.getType(i) == ReadableType.String) {
+              String sizeString = sizesArray.getString(i);
+              sizeList.add(ReactNativeGoogleMobileAdsCommon.getAdSize(sizeString, reactViewGroup));
+            }
+          }
+
+          if (!sizeList.isEmpty() && !sizeList.contains(AdSize.FLUID)) {
+            AdSize adSize = sizeList.get(0);
+            WritableMap payload = Arguments.createMap();
+            payload.putDouble("width", adSize.getWidth());
+            payload.putDouble("height", adSize.getHeight());
+            sendEvent(reactViewGroup, EVENT_SIZE_CHANGE, payload);
+          }
+
+          reactViewGroup.setSizes(sizeList);
+        }
+      }
+
+      reactViewGroup.setPropsChanged(true);
+    }
+  }
+
+  @ReactProp(name = "manualImpressionsEnabled")
+  public void setManualImpressionsEnabled(ReactNativeAdView reactViewGroup, boolean value) {
+    reactViewGroup.setManualImpressionsEnabled(value);
+    reactViewGroup.setPropsChanged(true);
+  }
+
+  @Override
+  public void onAfterUpdateTransaction(@NonNull ReactNativeAdView reactViewGroup) {
+    super.onAfterUpdateTransaction(reactViewGroup);
+    if (reactViewGroup.getPropsChanged()) {
+      requestAd(reactViewGroup);
+    }
+    reactViewGroup.setPropsChanged(false);
+  }
+
+  @Override
+  public void onDropViewInstance(@NonNull ReactNativeAdView reactViewGroup) {
+    AdView adView = getAdView(reactViewGroup);
+    if (adView != null) {
+      adView.destroy();
+      reactViewGroup.removeView(adView);
+    }
+    super.onDropViewInstance(reactViewGroup);
+  }
+
+  private AdView initAdView(ReactNativeAdView reactViewGroup) {
+    AdView oldAdView = getAdView(reactViewGroup);
+    if (oldAdView != null) {
+      oldAdView.destroy();
+      reactViewGroup.removeView(oldAdView);
+    }
+
+    AdView adView = new AdView(reactViewGroup.getContext());
+    adView.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
+    reactViewGroup.addView(adView);
+    return adView;
+  }
+
+  @Nullable
+  private AdView getAdView(ViewGroup reactViewGroup) {
+    if (reactViewGroup.getChildCount() == 0) return null;
+    android.view.View child = reactViewGroup.getChildAt(0);
+    return child instanceof AdView ? (AdView) child : null;
+  }
+
+  private BannerAdEventCallback buildEventCallback(ReactNativeAdView reactViewGroup) {
+    return new BannerAdEventCallback() {
+      @Override
+      public void onAdImpression() {
+        sendEvent(reactViewGroup, EVENT_AD_IMPRESSION, null);
+      }
+
+      @Override
+      public void onAdClicked() {
+        sendEvent(reactViewGroup, EVENT_AD_CLICKED, null);
+      }
+
+      @Override
+      public void onAdShowedFullScreenContent() {
+        sendEvent(reactViewGroup, EVENT_AD_OPENED, null);
+      }
+
+      @Override
+      public void onAdDismissedFullScreenContent() {
+        sendEvent(reactViewGroup, EVENT_AD_CLOSED, null);
+      }
+
+      @Override
+      public void onAdPaid(@NonNull AdValue adValue) {
+        WritableMap payload = Arguments.createMap();
+        payload.putDouble("value", 1e-6 * adValue.getValueMicros());
+        payload.putDouble("precision", adValue.getPrecisionType().ordinal());
+        payload.putString("currency", adValue.getCurrencyCode());
+        sendEvent(reactViewGroup, EVENT_PAID, payload);
+      }
+    };
+  }
+
+  private void requestAd(ReactNativeAdView reactViewGroup) {
+    String unitId = reactViewGroup.getUnitId();
+    List<AdSize> sizes = reactViewGroup.getSizes();
+    ReadableMap requestOptions = reactViewGroup.getRequestOptions();
+    Boolean manualImpressionsEnabled = reactViewGroup.getManualImpressionsEnabled();
+
+    if (sizes == null || sizes.isEmpty() || unitId == null || requestOptions == null) {
+      return;
+    }
+
+    final AdSize adSize = sizes.get(0);
+    reactViewGroup.setIsFluid(adSize.equals(AdSize.FLUID));
+
+    BannerAdRequest.Builder builder = new BannerAdRequest.Builder(unitId, adSize);
+    ReactNativeGoogleMobileAdsCommon.applyRequestOptions(builder, requestOptions);
+    if (manualImpressionsEnabled != null && manualImpressionsEnabled) {
+      builder.setManualImpressionEnabled(true);
+    }
+    BannerAdRequest request = builder.build();
+
+    final AdView adView = initAdView(reactViewGroup);
+    adView.loadAd(
+        request,
+        new AdLoadCallback<BannerAd>() {
+          @Override
+          public void onAdLoaded(@NonNull BannerAd ad) {
+            ad.setAdEventCallback(buildEventCallback(reactViewGroup));
+
+            AdSize loadedSize = ad.getAdSize() != null ? ad.getAdSize() : adSize;
+            WritableMap payload = Arguments.createMap();
+            payload.putDouble("width", loadedSize.getWidth());
+            payload.putDouble("height", loadedSize.getHeight());
+            sendEvent(reactViewGroup, EVENT_AD_LOADED, payload);
+          }
+
+          @Override
+          public void onAdFailedToLoad(@NonNull LoadAdError loadAdError) {
+            WritableMap payload =
+                ReactNativeGoogleMobileAdsCommon.errorCodeToMap(loadAdError.getCode());
+            sendEvent(reactViewGroup, EVENT_AD_FAILED_TO_LOAD, payload);
+          }
+        });
+  }
+
+  private void sendEvent(ReactNativeAdView reactViewGroup, String type, WritableMap payload) {
+    WritableMap event = Arguments.createMap();
+    event.putString("type", type);
+
+    if (payload != null) {
+      event.merge(payload);
+    }
+
+    ThemedReactContext themedReactContext = ((ThemedReactContext) reactViewGroup.getContext());
+    EventDispatcher eventDispatcher =
+        UIManagerHelper.getEventDispatcherForReactTag(themedReactContext, reactViewGroup.getId());
+    if (eventDispatcher != null) {
+      eventDispatcher.dispatchEvent(new OnNativeEvent(reactViewGroup.getId(), event));
+    }
+  }
+}

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

@@ -0,0 +1,277 @@
+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.os.Bundle;
+import android.util.DisplayMetrics;
+import android.view.Display;
+import android.view.ViewGroup;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableMap;
+// GMA Next-Gen SDK (com.google.android.libraries.ads.mobile.sdk) — replaces the
+// legacy play-services-ads (com.google.android.gms.ads) on Android. iOS is untouched.
+import com.google.android.libraries.ads.mobile.sdk.banner.AdSize;
+import com.google.android.libraries.ads.mobile.sdk.common.BaseError;
+import com.google.android.libraries.ads.mobile.sdk.common.BaseRequestBuilder;
+import com.google.android.libraries.ads.mobile.sdk.common.LoadAdError;
+import io.invertase.googlemobileads.common.ReactNativeAdView;
+import io.invertase.googlemobileads.common.ReactNativeEventEmitter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+
+public class ReactNativeGoogleMobileAdsCommon {
+
+  static AdSize getAdSizeForAdaptiveBanner(String preDefinedAdSize, ViewGroup reactViewGroup) {
+
+    try {
+      Display display =
+          Objects.requireNonNull(((ReactContext) reactViewGroup.getContext()).getCurrentActivity())
+              .getWindowManager()
+              .getDefaultDisplay();
+
+      DisplayMetrics outMetrics = new DisplayMetrics();
+      display.getMetrics(outMetrics);
+
+      // Get custom width if set, otherwise use device width
+      float customWidth = ((ReactNativeAdView) reactViewGroup).getAdWidth();
+      int screenWidth = (int) (outMetrics.widthPixels / outMetrics.density);
+      int adWidth = customWidth > 0 ? Math.min(Math.round(customWidth), screenWidth) : screenWidth;
+
+      float maxAdHeight = ((ReactNativeAdView) reactViewGroup).getMaxAdHeight();
+      if ("INLINE_ADAPTIVE_BANNER".equals(preDefinedAdSize)) {
+        if (maxAdHeight > 0) {
+          return AdSize.getInlineAdaptiveBannerAdSize(
+              adWidth, Math.round(Math.max(maxAdHeight, 32)));
+        }
+        return AdSize.getCurrentOrientationInlineAdaptiveBannerAdSize(
+            reactViewGroup.getContext(), adWidth);
+      }
+      if ("LARGE_ANCHORED_ADAPTIVE_BANNER".equals(preDefinedAdSize)) {
+        return AdSize.getLargeAnchoredAdaptiveBannerAdSize(reactViewGroup.getContext(), adWidth);
+      }
+      return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(
+          reactViewGroup.getContext(), adWidth);
+    } catch (Exception e) {
+      return AdSize.BANNER;
+    }
+  }
+
+  static AdSize getAdSize(String preDefinedAdSize, ViewGroup reactViewGroup) {
+    if (preDefinedAdSize.matches(
+        "ANCHORED_ADAPTIVE_BANNER|LARGE_ANCHORED_ADAPTIVE_BANNER|INLINE_ADAPTIVE_BANNER")) {
+      return ReactNativeGoogleMobileAdsCommon.getAdSizeForAdaptiveBanner(
+          preDefinedAdSize, reactViewGroup);
+    } else {
+      return ReactNativeGoogleMobileAdsCommon.stringToAdSize(preDefinedAdSize);
+    }
+  }
+
+  static AdSize stringToAdSize(String value) {
+    Pattern pattern = Pattern.compile("([0-9]+)x([0-9]+)");
+    Matcher matcher = pattern.matcher(value);
+
+    // If size is "valXval"
+    if (matcher.find()) {
+      int width = Integer.parseInt(matcher.group(1));
+      int height = Integer.parseInt(matcher.group(2));
+      return new AdSize(width, height);
+    }
+
+    switch (value.toUpperCase()) {
+      case "FLUID":
+        return AdSize.FLUID;
+      case "WIDE_SKYSCRAPER":
+        // Next-Gen AdSize has no WIDE_SKYSCRAPER constant; use the same 160x600 dimensions.
+        return new AdSize(160, 600);
+      case "LARGE_BANNER":
+        return AdSize.LARGE_BANNER;
+      case "MEDIUM_RECTANGLE":
+        return AdSize.MEDIUM_RECTANGLE;
+      case "FULL_BANNER":
+        return AdSize.FULL_BANNER;
+      case "LEADERBOARD":
+        return AdSize.LEADERBOARD;
+      default:
+      case "BANNER":
+        return AdSize.BANNER;
+    }
+  }
+
+  /** Convert a Next-Gen load-error code into the JS-facing error code/message pair. */
+  static WritableMap errorCodeToMap(LoadAdError.ErrorCode errorCode) {
+    WritableMap map = Arguments.createMap();
+
+    switch (errorCode) {
+      case INTERNAL_ERROR:
+        map.putString("code", "error-code-internal-error");
+        map.putString(
+            "message",
+            "Something happened internally; for instance, an invalid response was received from the"
+                + " ad server.");
+        break;
+      case INVALID_REQUEST:
+        map.putString("code", "error-code-invalid-request");
+        map.putString(
+            "message", "The ad request was invalid; for instance, the ad unit ID was incorrect.");
+        break;
+      case NETWORK_ERROR:
+        map.putString("code", "error-code-network-error");
+        map.putString("message", "The ad request was unsuccessful due to network connectivity.");
+        break;
+      case NO_FILL:
+        map.putString("code", "error-code-no-fill");
+        map.putString(
+            "message",
+            "The ad request was successful, but no ad was returned due to lack of ad inventory.");
+        break;
+      default:
+        map.putString("code", "error-code-internal-error");
+        map.putString("message", "Ad failed to load: " + errorCode.name());
+        break;
+    }
+
+    return map;
+  }
+
+  /**
+   * Apply the JS-supplied request options (keywords, content URL, non-personalized, etc.) onto any
+   * Next-Gen request builder. Works for both BannerAdRequest.Builder and AdRequest.Builder since
+   * both extend BaseRequestBuilder. AdMob-only: Ad Manager / GAM-specific options are not used by
+   * this app and are intentionally omitted.
+   */
+  public static void applyRequestOptions(
+      BaseRequestBuilder<?> builder, ReadableMap adRequestOptions) {
+    if (adRequestOptions == null) {
+      return;
+    }
+
+    if (adRequestOptions.hasKey("requestNonPersonalizedAdsOnly")
+        && adRequestOptions.getBoolean("requestNonPersonalizedAdsOnly")) {
+      Bundle extras = new Bundle();
+      extras.putString("npa", "1");
+      builder.setGoogleExtrasBundle(extras);
+    }
+
+    if (adRequestOptions.hasKey("keywords")) {
+      ArrayList<Object> keywords =
+          Objects.requireNonNull(adRequestOptions.getArray("keywords")).toArrayList();
+      for (Object keyword : keywords) {
+        builder.addKeyword((String) keyword);
+      }
+    }
+
+    if (adRequestOptions.hasKey("contentUrl")) {
+      builder.setContentUrl(Objects.requireNonNull(adRequestOptions.getString("contentUrl")));
+    }
+
+    if (adRequestOptions.hasKey("requestAgent")) {
+      builder.setRequestAgent(Objects.requireNonNull(adRequestOptions.getString("requestAgent")));
+    }
+
+    if (adRequestOptions.hasKey("customTargeting")) {
+      Map<String, Object> customTargeting = adRequestOptions.getMap("customTargeting").toHashMap();
+      for (Map.Entry<String, Object> entry : customTargeting.entrySet()) {
+        String key = entry.getKey();
+        Object value = entry.getValue();
+        if (value instanceof String) {
+          builder.putCustomTargeting(key, (String) value);
+        } else if (value instanceof List) {
+          ArrayList<String> values = new ArrayList<>();
+          for (Object item : (List<?>) value) {
+            values.add(String.valueOf(item));
+          }
+          builder.putCustomTargeting(key, values);
+        }
+      }
+    }
+
+    if (adRequestOptions.hasKey("publisherProvidedId")) {
+      builder.setPublisherProvidedId(
+          Objects.requireNonNull(adRequestOptions.getString("publisherProvidedId")));
+    }
+  }
+
+  public static void sendAdEvent(
+      String event, int requestId, String type, String adUnitId, @Nullable WritableMap error) {
+    ReactNativeEventEmitter emitter = ReactNativeEventEmitter.getSharedInstance();
+
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString("type", type);
+
+    if (error != null) {
+      eventBody.putMap("error", error);
+    }
+
+    emitter.sendEvent(new ReactNativeGoogleMobileAdsEvent(event, requestId, adUnitId, eventBody));
+  }
+
+  public static void sendAdEvent(
+      String event,
+      int requestId,
+      String type,
+      String adUnitId,
+      @Nullable WritableMap error,
+      @Nullable WritableMap data) {
+    ReactNativeEventEmitter emitter = ReactNativeEventEmitter.getSharedInstance();
+
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString("type", type);
+
+    if (error != null) {
+      eventBody.putMap("error", error);
+    }
+
+    if (data != null) {
+      eventBody.putMap("data", data);
+    }
+
+    emitter.sendEvent(new ReactNativeGoogleMobileAdsEvent(event, requestId, adUnitId, eventBody));
+  }
+
+  /** Extract a [code, message] pair from any Next-Gen error (LoadAdError, FullScreenContentError). */
+  public static String[] getCodeAndMessageFromAdError(BaseError<?> adError) {
+    String code = "unknown";
+    String message = adError.getMessage();
+
+    Object rawCode = adError.getCode();
+    if (rawCode instanceof Enum) {
+      code = ((Enum<?>) rawCode).name().toLowerCase().replace('_', '-');
+    } else if (rawCode != null) {
+      code = String.valueOf(rawCode);
+    }
+
+    String[] codeAndMessage = new String[2];
+    codeAndMessage[0] = code;
+    codeAndMessage[1] = message;
+    return codeAndMessage;
+  }
+
+  public static boolean isAdManagerUnit(String unitId) {
+    if (unitId == null) return false;
+    return unitId.startsWith("/");
+  }
+}