react-native-google-mobile-ads 4.1.0

package/src/RewardedAdEventType.ts

@@ -0,0 +1,64 @@
+/*
+ * 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.
+ *
+ */
+
+export enum RewardedAdEventType {
+  /**
+   * An event fired when a rewarded ad has loaded.
+   *
+   * This type differs from `AdEventType.LOADED` as when a rewarded ad is loaded,
+   * an additional data payload is provided to the event handler containing the ad reward
+   * (assuming the user earns the reward).
+   *
+   * The reward contains a `type` and `amount`.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
+   *
+   * rewardedAd.onAdEvent((type, error, data) => {
+   *   if (type === RewardedAdEventType.LOADED) {
+   *     console.log(`Rewarded Ad loaded with ${data.amount} ${data.type} as reward`);
+   *     // E.g. "Rewarded Ad loaded with 50 coins as reward"
+   *     rewardedAd.show();
+   *   }
+   * });
+   * ```
+   */
+  LOADED = 'rewarded_loaded',
+
+  /**
+   * An event fired when the user earned the reward for the video. If the user does not earn a reward,
+   * the `AdEventType.CLOSED` event will be fired with no rewarded event.
+   *
+   * The reward contains a `type` and `amount`.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { RewardedAdEventType } from 'react-native-google-mobile-ads';
+   *
+   * rewardedAd.onAdEvent((type, error, data) => {
+   *   if (type === RewardedAdEventType.EARNED_REWARD) {
+   *     console.log(`User earned ${data.amount} ${data.type}`);
+   *     // E.g. "User earned 50 coins"
+   *   }
+   * });
+   * ```
+   */
+  EARNED_REWARD = 'rewarded_earned_reward',
+}

package/src/TestIds.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 { Platform } from 'react-native';
+
+export const TestIds = {
+  APP_OPEN: '',
+  BANNER: '',
+  INTERSTITIAL: '',
+  REWARDED: '',
+  ...Platform.select({
+    android: {
+      APP_OPEN: 'ca-app-pub-3940256099942544/3419835294',
+      BANNER: 'ca-app-pub-3940256099942544/6300978111',
+      INTERSTITIAL: 'ca-app-pub-3940256099942544/1033173712',
+      REWARDED: 'ca-app-pub-3940256099942544/5224354917',
+    },
+    ios: {
+      APP_OPEN: 'ca-app-pub-3940256099942544/5662855259',
+      BANNER: 'ca-app-pub-3940256099942544/2934735716',
+      INTERSTITIAL: 'ca-app-pub-3940256099942544/4411468910',
+      REWARDED: 'ca-app-pub-3940256099942544/1712485313',
+    },
+  }),
+};

package/src/ads/AppOpenAd.ts

@@ -0,0 +1,85 @@
+/*
+ * 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 { isFunction, isString } from '../common';
+import { MobileAds } from '../MobileAds';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { validateAdShowOptions } from '../validateAdShowOptions';
+import { MobileAd } from './MobileAd';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdShowOptions } from '../types/AdShowOptions';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
+
+let _appOpenRequest = 0;
+
+export class AppOpenAd extends MobileAd implements MobileAdInterface {
+  static createForAdRequest(adUnitId: string, requestOptions?: RequestOptions): AppOpenAd {
+    if (!isString(adUnitId)) {
+      throw new Error("AppOpenAd.createForAdRequest(*) 'adUnitId' expected an string value.");
+    }
+
+    let options = {};
+    try {
+      options = validateAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`AppOpenAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const requestId = _appOpenRequest++;
+    return new AppOpenAd('app_open', MobileAds(), requestId, adUnitId, options);
+  }
+
+  load() {
+    // Prevent multiple load calls
+    if (this._loaded || this._isLoadCalled) {
+      return;
+    }
+
+    this._isLoadCalled = true;
+    this._googleMobileAds.native.appOpenLoad(this._requestId, this._adUnitId, this._requestOptions);
+  }
+
+  onAdEvent(handler: AdEventListener) {
+    if (!isFunction(handler)) {
+      throw new Error("AppOpenAd.onAdEvent(*) 'handler' expected a function.");
+    }
+
+    return this._setAdEventHandler(handler);
+  }
+
+  show(showOptions?: AdShowOptions) {
+    if (!this._loaded) {
+      throw new Error(
+        'AppOpenAd.show() The requested AppOpenAd has not loaded and could not be shown.',
+      );
+    }
+
+    let options;
+    try {
+      options = validateAdShowOptions(showOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`AppOpenAd.show(*) ${e.message}.`);
+      }
+    }
+
+    return this._googleMobileAds.native.appOpenShow(this._requestId, options);
+  }
+}

package/src/ads/BannerAd.tsx

@@ -0,0 +1,126 @@
+/*
+ * 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 React, { useState, useEffect } from 'react';
+import { HostComponent, requireNativeComponent } from 'react-native';
+import { isFunction } from '../common';
+import { NativeError } from '../internal/NativeError';
+import { BannerAdSize } from '../BannerAdSize';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { BannerAdProps } from '../types/BannerAdProps';
+import { RequestOptions } from '../types/RequestOptions';
+
+type NativeEvent =
+  | {
+      type: 'onAdLoaded' | 'onSizeChange';
+      width: number;
+      height: number;
+    }
+  | { type: 'onAdOpened' | 'onAdClosed' }
+  | {
+      type: 'onAdFailedToLoad';
+      code: string;
+      message: string;
+    };
+
+const initialState = [0, 0];
+const sizeRegex = /([0-9]+)x([0-9]+)/;
+
+export function BannerAd({ unitId, size, requestOptions, ...props }: BannerAdProps) {
+  const [dimensions, setDimensions] = useState(initialState);
+
+  useEffect(() => {
+    if (!unitId) {
+      throw new Error("BannerAd: 'unitId' expected a valid string unit ID.");
+    }
+  }, [unitId]);
+
+  useEffect(() => {
+    if (!(size in BannerAdSize) && !sizeRegex.test(size)) {
+      throw new Error("BannerAd: 'size' expected a valid BannerAdSize or custom size string.");
+    }
+  }, [size]);
+
+  useEffect(() => {
+    if (!(size in BannerAdSize) && !sizeRegex.test(size)) {
+      throw new Error("BannerAd: 'size' expected a valid BannerAdSize or custom size string.");
+    }
+  }, [size]);
+
+  const parsedRequestOptions = JSON.stringify(requestOptions);
+
+  useEffect(() => {
+    if (requestOptions) {
+      try {
+        validateAdRequestOptions(requestOptions);
+      } catch (e) {
+        if (e instanceof Error) {
+          throw new Error(`BannerAd: ${e.message}`);
+        }
+      }
+    }
+  }, [parsedRequestOptions]);
+
+  function onNativeEvent({ nativeEvent }: { nativeEvent: NativeEvent }) {
+    const { type } = nativeEvent;
+
+    if (type !== 'onSizeChange' && isFunction(props[type])) {
+      let eventHandler;
+      if (type === 'onAdFailedToLoad') {
+        const eventPayload = NativeError.fromEvent(nativeEvent, 'googleMobileAds');
+        if ((eventHandler = props[type])) eventHandler(eventPayload);
+      } else if ((eventHandler = props[type])) eventHandler();
+    }
+
+    if ((type === 'onAdLoaded' || type === 'onSizeChange') && size !== 'FLUID') {
+      const { width, height } = nativeEvent;
+      if (width && height) setDimensions([width, height]);
+    }
+  }
+
+  let style;
+  if (size === 'FLUID') {
+    // @ts-ignore: Property 'style' does not exist on type error
+    style = props.style;
+  } else {
+    style = {
+      width: dimensions[0],
+      height: dimensions[1],
+    };
+  }
+
+  return (
+    <GoogleMobileAdsBannerView
+      size={size}
+      style={style}
+      unitId={unitId}
+      request={validateAdRequestOptions(requestOptions)}
+      onNativeEvent={onNativeEvent}
+    />
+  );
+}
+
+const GoogleMobileAdsBannerView: HostComponent<{
+  size: BannerAdProps['size'];
+  style: {
+    width: number;
+    height: number;
+  };
+  unitId: string;
+  request: RequestOptions;
+  onNativeEvent: (event: { nativeEvent: NativeEvent }) => void;
+}> = requireNativeComponent('RNGoogleMobileAdsBannerView');

package/src/ads/InterstitialAd.ts

@@ -0,0 +1,156 @@
+/*
+ * 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 { isFunction, isString } from '../common';
+import { MobileAds } from '../MobileAds';
+import { validateAdRequestOptions } from '../validateAdRequestOptions';
+import { validateAdShowOptions } from '../validateAdShowOptions';
+import { MobileAd } from './MobileAd';
+import { AdEventListener } from '../types/AdEventListener';
+import { AdShowOptions } from '../types/AdShowOptions';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdInterface } from '../types/MobileAd.interface';
+
+let _interstitialRequest = 0;
+
+/**
+ * A class for interacting and showing Interstitial Ads.
+ *
+ * An 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. An Interstitial is a full screen advert, laid on-top of your entire application which the user can interact with.
+ * Interactions are passed back via events which should be handled accordingly inside of your app.
+ *
+ * #### Example
+ *
+ * First create a new 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 { InterstitialAd, TestIds } from 'react-native-google-mobile-ads';
+ *
+ * const interstitial = InterstitialAd.createForAdRequest(TestIds.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` interface. Once the advert has loaded, we can trigger it to show:
+ *
+ * ```js
+ * import { AdEventType } from 'react-native-google-mobile-ads';
+ *
+ * interstitial.onAdEvent((type) => {
+ *   if (type === AdEventType.LOADED) {
+ *     interstitial.show();
+ *   }
+ * });
+ *
+ * interstitial.load();
+ *  ```
+ *
+ * The advert will be presented to the user, and several more events can be triggered such as the user clicking the
+ * advert or closing it.
+ */
+export class InterstitialAd extends MobileAd implements MobileAdInterface {
+  /**
+   * Creates a new InterstitialAd instance.
+   *
+   * #### Example
+   *
+   * ```js
+   * import { InterstitialAd, AdEventType, TestIds } from 'react-native-google-mobile-ads';
+   *
+   * const interstitialAd = await InterstitialAd.createForAdRequest(TestIds.INTERSTITIAL, {
+   *   requestAgent: 'CoolAds',
+   * });
+   *
+   * interstitialAd.onAdEvent((type, error) => {
+   *   console.log('New event: ', type, error);
+   *
+   *   if (type === AdEventType.LOADED) {
+   *     interstitialAd.show();
+   *   }
+   * });
+   *
+   * interstitialAd.load();
+   * ```
+   *
+   * @param adUnitId The Ad Unit ID for the Interstitial. 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): InterstitialAd {
+    if (!isString(adUnitId)) {
+      throw new Error("InterstitialAd.createForAdRequest(*) 'adUnitId' expected an string value.");
+    }
+
+    let options = {};
+    try {
+      options = validateAdRequestOptions(requestOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`InterstitialAd.createForAdRequest(_, *) ${e.message}.`);
+      }
+    }
+
+    const requestId = _interstitialRequest++;
+    return new InterstitialAd('interstitial', MobileAds(), requestId, adUnitId, options);
+  }
+
+  load() {
+    // Prevent multiple load calls
+    if (this._loaded || this._isLoadCalled) {
+      return;
+    }
+
+    this._isLoadCalled = true;
+    this._googleMobileAds.native.interstitialLoad(
+      this._requestId,
+      this._adUnitId,
+      this._requestOptions,
+    );
+  }
+
+  onAdEvent(handler: AdEventListener) {
+    if (!isFunction(handler)) {
+      throw new Error("InterstitialAd.onAdEvent(*) 'handler' expected a function.");
+    }
+
+    return this._setAdEventHandler(handler);
+  }
+
+  show(showOptions?: AdShowOptions) {
+    if (!this._loaded) {
+      throw new Error(
+        'InterstitialAd.show() The requested InterstitialAd has not loaded and could not be shown.',
+      );
+    }
+
+    let options;
+    try {
+      options = validateAdShowOptions(showOptions);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`InterstitialAd.show(*) ${e.message}.`);
+      }
+    }
+
+    return this._googleMobileAds.native.interstitialShow(this._requestId, options);
+  }
+}

package/src/ads/MobileAd.ts

@@ -0,0 +1,101 @@
+/*
+ * 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 { NativeError } from '../internal/NativeError';
+import { RewardedAdEventType } from '../RewardedAdEventType';
+import { AdEventType } from '../AdEventType';
+import { AdEventListener } from '../types/AdEventListener';
+import { RequestOptions } from '../types/RequestOptions';
+import { MobileAdsModuleInterface } from '../types/MobileAdsModule.interface';
+import { RewardedAdReward } from '../types/RewardedAdReward';
+
+export class MobileAd {
+  _type: 'app_open' | 'interstitial' | 'rewarded';
+  _googleMobileAds: MobileAdsModuleInterface;
+  _requestId: number;
+  _adUnitId: string;
+  _requestOptions: RequestOptions;
+  _loaded: boolean;
+  _isLoadCalled: boolean;
+  _onAdEventHandler: AdEventListener | null;
+  _nativeListener: EmitterSubscription;
+
+  constructor(
+    type: 'app_open' | 'interstitial' | 'rewarded',
+    googleMobileAds: MobileAdsModuleInterface,
+    requestId: number,
+    adUnitId: string,
+    requestOptions: RequestOptions,
+  ) {
+    this._type = type;
+    this._googleMobileAds = googleMobileAds;
+    this._requestId = requestId;
+    this._adUnitId = adUnitId;
+    this._requestOptions = requestOptions;
+
+    this._loaded = false;
+    this._isLoadCalled = false;
+    this._onAdEventHandler = null;
+
+    this._nativeListener = googleMobileAds.emitter.addListener(
+      `google_mobile_ads_${type}_event:${adUnitId}:${requestId}`,
+      this._handleAdEvent.bind(this),
+    );
+  }
+
+  _handleAdEvent(event: {
+    body: {
+      type: AdEventType | RewardedAdEventType;
+      error?: { code: string; message: string };
+      data?: RewardedAdReward;
+    };
+  }) {
+    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 (this._onAdEventHandler) {
+      let nativeError;
+      if (error) {
+        nativeError = NativeError.fromEvent(error, 'googleMobileAds');
+      }
+
+      this._onAdEventHandler(type, nativeError, data);
+    }
+  }
+
+  _setAdEventHandler(handler: AdEventListener) {
+    this._onAdEventHandler = handler;
+    return () => (this._onAdEventHandler = null);
+  }
+
+  get adUnitId() {
+    return this._adUnitId;
+  }
+
+  get loaded() {
+    return this._loaded;
+  }
+}