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

package/src/ads/MobileAd.ts

@@ -0,0 +1,227 @@
+/*
+ * 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 { EmitterSubscription } from 'react-native';
+import { isFunction, isOneOf } from '../common';
+import { NativeError } from '../internal/NativeError';
+import { AdEventType } from '../AdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { SharedEventEmitter } from '../internal/SharedEventEmitter';
+import { AdEventListener, AdEventPayload } from '../types/AdEventListener';
+import { AdEventsListener } from '../types/AdEventsListener';
+import { AdShowOptions } from '../types/AdShowOptions';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
+import { RewardedAdReward } from '../types/RewardedAdReward';
+import { GAMAdEventType } from '../GAMAdEventType';
+import { AppEvent } from '../types/AppEvent';
+import { validateAdShowOptions } from '../validateAdShowOptions';
+
+type AdType = 'app_open' | 'interstitial' | 'rewarded' | 'rewarded_interstitial';
+type EventType = AdEventType | RewardedAdEventType | GAMAdEventType;
+type AdLoadFunction = (requestId: number, adUnitId: string, requestOptions: RequestOptions) => void;
+type AdShowFunction = (
+  requestId: number,
+  adUnitId: string,
+  showOptions?: AdShowOptions,
+) => Promise<void>;
+
+export abstract class MobileAd implements MobileAdInterface {
+  protected _type: AdType;
+  protected _requestId: number;
+  protected _adUnitId: string;
+  protected _adLoadFunction: AdLoadFunction;
+  protected _adShowFunction: AdShowFunction;
+  protected _requestOptions: RequestOptions;
+  protected _loaded: boolean;
+  protected _isLoadCalled: boolean;
+  protected _adEventsListeners: Map<number, AdEventsListener<EventType>>;
+  protected _adEventListenersMap: Map<EventType, Map<number, AdEventListener<EventType>>>;
+  protected _adEventsListenerId: number;
+  protected _adEventListenerId: number;
+  protected _nativeListener: EmitterSubscription;
+
+  protected constructor(
+    type: AdType,
+    requestId: number,
+    adUnitId: string,
+    adLoadFunction: AdLoadFunction,
+    adShowFunction: AdShowFunction,
+    requestOptions: RequestOptions,
+  ) {
+    this._type = type;
+    this._requestId = requestId;
+    this._adUnitId = adUnitId;
+    this._adLoadFunction = adLoadFunction;
+    this._adShowFunction = adShowFunction;
+    this._requestOptions = requestOptions;
+
+    this._loaded = false;
+    this._isLoadCalled = false;
+    this._adEventsListeners = new Map();
+    this._adEventListenersMap = new Map();
+    Object.values({
+      ...AdEventType,
+      ...RewardedAdEventType,
+      ...GAMAdEventType,
+      _: AdEventType.LOADED, // since AdEventType.LOADED is overwritten by RewardedAdEventType.LOADED
+    }).forEach(type => {
+      this._adEventListenersMap.set(type as EventType, new Map());
+    });
+    this._adEventListenerId = 0;
+    this._adEventsListenerId = 0;
+
+    this._nativeListener = SharedEventEmitter.addListener(
+      `google_mobile_ads_${type}_event:${adUnitId}:${requestId}`,
+      this._handleAdEvent.bind(this),
+    );
+  }
+
+  protected _handleAdEvent(event: {
+    body: {
+      type: EventType;
+      error?: { code: string; message: string };
+      data?: RewardedAdReward | AppEvent;
+    };
+  }) {
+    const { type, error, data } = event.body;
+
+    if (type === AdEventType.LOADED || type === RewardedAdEventType.LOADED) {
+      this._loaded = true;
+    }
+
+    if (type === AdEventType.CLOSED) {
+      this._loaded = false;
+      this._isLoadCalled = false;
+    }
+
+    if (type === AdEventType.ERROR) {
+      this._loaded = false;
+      this._isLoadCalled = false;
+    }
+
+    let payload: AdEventPayload<EventType> = data;
+    if (error) {
+      payload = NativeError.fromEvent(error, 'googleMobileAds');
+    }
+    this._adEventsListeners.forEach(listener => {
+      listener({
+        type,
+        payload,
+      });
+    });
+    this._getAdEventListeners(type).forEach(listener => {
+      listener(payload);
+    });
+  }
+
+  protected _addAdEventsListener<T extends EventType>(listener: AdEventsListener<T>) {
+    if (!isFunction(listener)) {
+      throw new Error(`${this._className}.addAdEventsListener(*) 'listener' expected a function.`);
+    }
+
+    const id = this._adEventsListenerId++;
+    this._adEventsListeners.set(id, listener as AdEventsListener<EventType>);
+    return () => {
+      this._adEventsListeners.delete(id);
+    };
+  }
+
+  protected _addAdEventListener<T extends EventType>(type: T, listener: AdEventListener<T>) {
+    if (
+      !(
+        isOneOf(type, Object.values(AdEventType)) ||
+        isOneOf(type, Object.values(GAMAdEventType)) ||
+        (isOneOf(type, Object.values(RewardedAdEventType)) &&
+          (this._type === 'rewarded' || this._type === 'rewarded_interstitial'))
+      )
+    ) {
+      throw new Error(
+        `${this._className}.addAdEventListener(*) 'type' expected a valid event type value.`,
+      );
+    }
+    if (!isFunction(listener)) {
+      throw new Error(
+        `${this._className}.addAdEventListener(_, *) 'listener' expected a function.`,
+      );
+    }
+
+    const id = this._adEventListenerId++;
+    this._getAdEventListeners(type).set(id, listener);
+    return () => {
+      this._getAdEventListeners(type).delete(id);
+    };
+  }
+
+  protected _getAdEventListeners<T extends EventType>(type: T) {
+    return this._adEventListenersMap.get(type) as Map<number, AdEventListener<T>>;
+  }
+
+  protected get _className() {
+    return this.constructor.name;
+  }
+
+  public load() {
+    // Prevent multiple load calls
+    if (this._loaded || this._isLoadCalled) {
+      return;
+    }
+
+    this._isLoadCalled = true;
+    this._adLoadFunction(this._requestId, this._adUnitId, this._requestOptions);
+  }
+
+  public show(showOptions?: AdShowOptions) {
+    if (!this._loaded) {
+      throw new Error(
+        `${this._className}.show() The requested ${this._className} has not loaded and could not be shown.`,
+      );
+    }
+
+    let options;
+    try {
+      options = validateAdShowOptions(showOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`${this._className}.show(*) ${e.message}.`);
+      } else {
+        throw e;
+      }
+    }
+
+    return this._adShowFunction(this._requestId, this._adUnitId, options);
+  }
+
+  public abstract addAdEventsListener<T extends never>(listener: AdEventsListener<T>): () => void;
+
+  public abstract addAdEventListener<T extends never>(type: T, listener: AdEventListener<T>): void;
+
+  public removeAllListeners() {
+    this._adEventsListeners.clear();
+    this._adEventListenersMap.forEach((_, type, map) => {
+      map.set(type, new Map());
+    });
+  }
+
+  public get adUnitId() {
+    return this._adUnitId;
+  }
+
+  public get loaded() {
+    return this._loaded;
+  }
+}

package/src/ads/RewardedAd.ts

@@ -0,0 +1,142 @@
+/*
+ * 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 { isString } from '../common';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { MobileAd } from './MobileAd';
+import { AdEventType } from '../AdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdEventsListener } from '../types/AdEventsListener';
+import { RequestOptions } from '../types/RequestOptions';
+import NativeRewardedModule from '../specs/modules/NativeRewardedModule';
+
+/**
+ * A class for interacting and showing Rewarded Ads.
+ *
+ * An Rewarded advert can be pre-loaded and shown at a suitable point in your apps flow, such as at the end of a level
+ * in a game. The content of a rewarded advert can be controlled via your Google Mobile Ads dashboard. Typically users are rewarded
+ * after completing a specific advert action (e.g. watching a video or submitting an option via an interactive form).
+ * Events (such as the user earning a reward or closing a rewarded advert early) are sent back for you to handle accordingly
+ * within your application.
+ *
+ * #### Example
+ *
+ * First create a new Rewarded instance, passing in your Ad Unit ID from the Google Mobile Ads configuration console, and any additional
+ * request options. The example below will present a test advert, and only request a non-personalized ad.
+ *
+ * ```js
+ * import { RewardedAd, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * const rewarded = RewardedAd.createForAdRequest(TestIds.REWARDED, {
+ *     requestNonPersonalizedAdsOnly: true,
+ * });
+ *  ```
+ *
+ * Each advert needs to be loaded from Google Mobile Ads before being shown. It is recommended this is performed before the user
+ * reaches the checkpoint to show the advert, so it's ready to go. Before loading the advert, we need to setup
+ * event listeners to listen for updates from Google Mobile Ads, such as advert loaded or failed to load.
+ *
+ * Event types match the `AdEventType` or `RewardedAdEventType` interface. The potential user reward for rewarded
+ * adverts are passed back to the event handler on advert load and when the user earns the reward.
+ *
+ * ```js
+ * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
+ *
+ * rewarded.addAdEventListener(RewardedAdEventType.LOADED. () => {
+ *   rewarded.show();
+ * });
+ * rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+ *   console.log('User earned reward of ', reward);
+ * });
+ *
+ * rewarded.load();
+ *  ```
+ *
+ * The rewarded advert will be presented to the user, and several more events can be triggered such as the user clicking the
+ * advert, closing it or completing the action.
+ */
+export class RewardedAd extends MobileAd {
+  protected static _rewardedRequest = 0;
+  /**
+   * Creates a new RewardedAd instance.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { RewardedAd, RewardedAdEventType, TestIds } from 'react-native-google-mobile-ads';
+   *
+   * const rewardedAd = await RewardedAd.createForAdRequest(TestIds.REWARDED, {
+   *   requestAgent: 'CoolAds',
+   * });
+   *
+   * rewarded.addAdEventListener(RewardedAdEventType.LOADED. () => {
+   *   rewarded.show();
+   * });
+   * rewarded.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+   *   console.log('User earned reward of ', reward);
+   * });
+   *
+   * rewardedAd.load();
+   * ```
+   *
+   * @param adUnitId The Ad Unit ID for the Rewarded Ad. You can find this on your Google Mobile Ads dashboard.
+   * @param requestOptions Optional RequestOptions used to load the ad.
+   */
+  static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions) {
+    if (!isString(adUnitId)) {
+      throw new Error("RewardedAd.createForAdRequest(*) 'adUnitId' expected an string value.");
+    }
+
+    let options = {};
+    try {
+      options = validateAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`RewardedAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const requestId = RewardedAd._rewardedRequest++;
+    return new RewardedAd(
+      'rewarded',
+      requestId,
+      adUnitId,
+      NativeRewardedModule.rewardedLoad.bind(this),
+      NativeRewardedModule.rewardedShow.bind(this),
+      options,
+    );
+  }
+
+  addAdEventsListener<T extends AdEventType | RewardedAdEventType>(
+    listener: AdEventsListener<T>,
+  ): () => void {
+    return this._addAdEventsListener(listener);
+  }
+
+  addAdEventListener<T extends AdEventType | RewardedAdEventType>(
+    type: T,
+    listener: AdEventListener<T>,
+  ) {
+    if (type === AdEventType.LOADED) {
+      throw new Error(
+        'RewardedAd.addAdEventListener(*) use RewardedAdEventType.LOADED instead of AdEventType.LOADED.',
+      );
+    }
+    return this._addAdEventListener(type, listener);
+  }
+}

package/src/ads/RewardedInterstitialAd.ts

@@ -0,0 +1,144 @@
+/*
+ * 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 { isString } from '../common';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { MobileAd } from './MobileAd';
+import { AdEventType } from '../AdEventType';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdEventsListener } from '../types/AdEventsListener';
+import { RequestOptions } from '../types/RequestOptions';
+import NativeRewardedInterstitialModule from '../specs/modules/NativeRewardedInterstitialModule';
+
+/**
+ * A class for interacting and showing Rewarded Interstitial Ads.
+ *
+ * An Rewarded Interstitial advert can be pre-loaded and shown at a suitable point in your apps flow, such as at the end of a level
+ * in a game. The content of a rewarded interstital advert can be controlled via your Google Mobile Ads dashboard. Typically users are rewarded
+ * after completing a specific advert action (e.g. watching a video or submitting an option via an interactive form).
+ * Events (such as the user earning a reward or closing a rewarded interstital advert early) are sent back for you to handle accordingly
+ * within your application.
+ *
+ * #### Example
+ *
+ * First create a new Rewarded Interstitial instance, passing in your Ad Unit ID from the Google Mobile Ads configuration console, and any additional
+ * request options. The example below will present a test advert, and only request a non-personalized ad.
+ *
+ * ```js
+ * import { RewardedInterstitialAd, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * const rewardedInterstitial = RewardedInterstitialAd.createForAdRequest(TestIds.REWARDED_INTERSTITIAL, {
+ *     requestNonPersonalizedAdsOnly: true,
+ * });
+ *  ```
+ *
+ * Each advert needs to be loaded from Google Mobile Ads before being shown. It is recommended this is performed before the user
+ * reaches the checkpoint to show the advert, so it's ready to go. Before loading the advert, we need to setup
+ * event listeners to listen for updates from Google Mobile Ads, such as advert loaded or failed to load.
+ *
+ * Event types match the `AdEventType` or `RewardedAdEventType` interface. The potential user reward for rewarded interstitial
+ * adverts are passed back to the event handler on advert load and when the user earns the reward.
+ *
+ * ```js
+ * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
+ *
+ * rewardedInterstitial.addAdEventListener(RewardedAdEventType.LOADED. () => {
+ *   rewarded.show();
+ * });
+ * rewardedInterstitial.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+ *   console.log('User earned reward of ', reward);
+ * });
+ *
+ * rewardedInterstitial.load();
+ *  ```
+ *
+ * The rewarded interstitial advert will be presented to the user, and several more events can be triggered such as the user clicking the
+ * advert, closing it or completing the action.
+ */
+export class RewardedInterstitialAd extends MobileAd {
+  protected static _rewardedInterstitialRequest = 0;
+  /**
+   * Creates a new RewardedInterstitialAd instance.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { RewardedInterstitialAd, RewardedAdEventType, TestIds } from 'react-native-google-mobile-ads';
+   *
+   * const rewardedInterstitialAd = await RewardedInterstitialAd.createForAdRequest(TestIds.REWARDED_INTERSTITIAL, {
+   *   requestAgent: 'CoolAds',
+   * });
+   *
+   * rewardedInterstitialAd.addAdEventListener(RewardedAdEventType.LOADED. () => {
+   *   rewardedInterstitialAd.show();
+   * });
+   * rewardedInterstitialAd.addAdEventListener(RewardedAdEventType.EARNED_REWARD. (reward) => {
+   *   console.log('User earned reward of ', reward);
+   * });
+   *
+   * rewardedInterstitialAd.load();
+   * ```
+   *
+   * @param adUnitId The Ad Unit ID for the Rewarded Interstitial Ad. You can find this on your Google Mobile Ads dashboard.
+   * @param requestOptions Optional RequestOptions used to load the ad.
+   */
+  static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions) {
+    if (!isString(adUnitId)) {
+      throw new Error(
+        "RewardedInterstitialAd.createForAdRequest(*) 'adUnitId' expected an string value.",
+      );
+    }
+
+    let options = {};
+    try {
+      options = validateAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`RewardedInterstitialAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const requestId = RewardedInterstitialAd._rewardedInterstitialRequest++;
+    return new RewardedInterstitialAd(
+      'rewarded_interstitial',
+      requestId,
+      adUnitId,
+      NativeRewardedInterstitialModule.rewardedInterstitialLoad.bind(this),
+      NativeRewardedInterstitialModule.rewardedInterstitialShow.bind(this),
+      options,
+    );
+  }
+
+  addAdEventsListener<T extends AdEventType | RewardedAdEventType>(
+    listener: AdEventsListener<T>,
+  ): () => void {
+    return this._addAdEventsListener(listener);
+  }
+
+  addAdEventListener<T extends AdEventType | RewardedAdEventType>(
+    type: T,
+    listener: AdEventListener<T>,
+  ) {
+    if (type === AdEventType.LOADED) {
+      throw new Error(
+        'RewardedInterstitialAd.addAdEventListener(*) use RewardedAdEventType.LOADED instead of AdEventType.LOADED.',
+      );
+    }
+    return this._addAdEventListener(type, listener);
+  }
+}

package/src/ads/native-ad/NativeAd.ts

@@ -0,0 +1,159 @@
+/*
+ * 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 { EventSubscription, NativeEventEmitter, Platform } from 'react-native';
+import EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter';
+
+import { NativeAdEventType } from '../../NativeAdEventType';
+import { isFunction, isOneOf, isString } from '../../common';
+import NativeGoogleMobileAdsNativeModule, {
+  NativeAdEventPayload,
+  NativeAdImage,
+  NativeAdPaidEventPayload,
+  NativeAdProps,
+  NativeMediaContent,
+} from '../../specs/modules/NativeGoogleMobileAdsNativeModule';
+import { NativeAdRequestOptions } from '../../types';
+import { validateNativeAdRequestOptions } from '../../validateNativeAdRequestOptions';
+
+type NativeAdListenerPayload<EventType extends NativeAdEventType> =
+  EventType extends NativeAdEventType.PAID ? NativeAdPaidEventPayload : never;
+
+/**
+ * A class for loading Native Ads.
+ */
+export class NativeAd {
+  readonly adUnitId: string;
+  readonly responseId: string;
+  readonly advertiser: string | null;
+  readonly body: string;
+  readonly callToAction: string;
+  readonly headline: string;
+  readonly price: string | null;
+  readonly store: string | null;
+  readonly starRating: number | null;
+  readonly icon: NativeAdImage | null;
+  readonly images: Array<NativeAdImage> | null;
+  readonly mediaContent: NativeMediaContent | null;
+  readonly extras: Record<string, unknown> | null;
+
+  private nativeEventSubscription: EventSubscription;
+  private eventEmitter: EventEmitter;
+
+  private constructor(adUnitId: string, props: NativeAdProps) {
+    this.adUnitId = adUnitId;
+    this.responseId = props.responseId;
+    this.advertiser = props.advertiser;
+    this.body = props.body;
+    this.callToAction = props.callToAction;
+    this.headline = props.headline;
+    this.price = props.price;
+    this.store = props.store;
+    this.starRating = props.starRating;
+    this.icon = props.icon;
+    this.images = props.images;
+    this.mediaContent = props.mediaContent;
+    this.extras = props.extras as Record<string, unknown>;
+
+    if ('onAdEvent' in NativeGoogleMobileAdsNativeModule) {
+      this.nativeEventSubscription = NativeGoogleMobileAdsNativeModule.onAdEvent(
+        this.onNativeAdEvent.bind(this),
+      );
+    } else {
+      let eventEmitter;
+      if (Platform.OS === 'ios') {
+        eventEmitter = new NativeEventEmitter(NativeGoogleMobileAdsNativeModule);
+      } else {
+        eventEmitter = new NativeEventEmitter();
+      }
+      this.nativeEventSubscription = eventEmitter.addListener(
+        'RNGMANativeAdEvent',
+        this.onNativeAdEvent.bind(this),
+      );
+    }
+    this.eventEmitter = new EventEmitter();
+  }
+
+  private onNativeAdEvent({ responseId, type, ...data }: NativeAdEventPayload) {
+    if (this.responseId !== responseId) {
+      return;
+    }
+    this.eventEmitter.emit(type, data);
+  }
+
+  addAdEventListener<EventType extends NativeAdEventType>(
+    type: EventType,
+    listener: (payload: NativeAdListenerPayload<EventType>) => void,
+  ) {
+    if (!isOneOf(type, Object.values(NativeAdEventType))) {
+      throw new Error(`NativeAd.addAdEventListener(*) 'type' expected a valid event type value.`);
+    }
+    if (!isFunction(listener)) {
+      throw new Error(`NativeAd.addAdEventListener(_, *) 'listener' expected a function.`);
+    }
+
+    return this.eventEmitter.addListener(type, listener);
+  }
+
+  removeAllAdEventListeners() {
+    this.eventEmitter.removeAllListeners();
+  }
+
+  destroy() {
+    NativeGoogleMobileAdsNativeModule.destroy(this.responseId);
+    this.nativeEventSubscription.remove();
+    this.removeAllAdEventListeners();
+  }
+
+  /**
+   * Creates a new NativeAd instance.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { NativeAd, AdEventType, TestIds } from 'react-native-google-mobile-ads';
+   *
+   * const nativeAd = await NativeAd.createForAdRequest(TestIds.NATIVE, {
+   *   requestAgent: 'CoolAds',
+   * });
+   * ```
+   *
+   * @param adUnitId The Ad Unit ID for the Native Ad. You can find this on your Google Mobile Ads dashboard.
+   * @param requestOptions Optional RequestOptions used to load the ad.
+   */
+  static async createForAdRequest(
+    adUnitId: string,
+    requestOptions?: NativeAdRequestOptions,
+  ): Promise<NativeAd> {
+    if (!isString(adUnitId)) {
+      throw new Error("NativeAd.createForAdRequest(*) 'adUnitId' expected an string value.");
+    }
+
+    let options = {};
+    try {
+      options = validateNativeAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`NativeAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const props = await NativeGoogleMobileAdsNativeModule.load(adUnitId, options);
+
+    return new NativeAd(adUnitId, props);
+  }
+}

package/src/ads/native-ad/NativeAdContext.ts

@@ -0,0 +1,26 @@
+/*
+ * 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 { NativeAd } from './NativeAd';
+import React, { createContext, RefObject } from 'react';
+import type GoogleMobileAdsNativeView from '../../specs/components/GoogleMobileAdsNativeViewNativeComponent';
+
+type NativeAdContextType = {
+  nativeAd: NativeAd;
+  viewRef: RefObject<React.ComponentRef<typeof GoogleMobileAdsNativeView> | null>;
+};
+export const NativeAdContext = createContext<NativeAdContextType>({} as NativeAdContextType);