react-native-google-mobile-ads 4.1.0

package/android/src/main/java/io/invertase/googlemobileads/common/TaskExecutorService.java

@@ -0,0 +1,124 @@
+package io.invertase.googlemobileads.common;
+
+/*
+ * 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 java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class TaskExecutorService {
+  private static final String MAXIMUM_POOL_SIZE_KEY = "android_task_executor_maximum_pool_size";
+  private static final String KEEP_ALIVE_SECONDS_KEY = "android_task_executor_keep_alive_seconds";
+
+  private final String name;
+  private final int maximumPoolSize;
+  private final int keepAliveSeconds;
+  private static final Map<String, ExecutorService> executors = new HashMap<>();
+
+  TaskExecutorService(String name) {
+    this.name = name;
+    ReactNativeJSON json = ReactNativeJSON.getSharedInstance();
+    this.maximumPoolSize = json.getIntValue(MAXIMUM_POOL_SIZE_KEY, 1);
+    this.keepAliveSeconds = json.getIntValue(KEEP_ALIVE_SECONDS_KEY, 3);
+  }
+
+  public ExecutorService getExecutor() {
+    boolean isTransactional = maximumPoolSize <= 1;
+    return getExecutor(isTransactional, "");
+  }
+
+  public ExecutorService getTransactionalExecutor() {
+    return getExecutor(true, "");
+  }
+
+  public ExecutorService getTransactionalExecutor(String identifier) {
+    String executorIdentifier = maximumPoolSize != 0 ? identifier : "";
+    return getExecutor(true, executorIdentifier);
+  }
+
+  public ExecutorService getExecutor(boolean isTransactional, String identifier) {
+    String executorName = getExecutorName(isTransactional, identifier);
+    synchronized (executors) {
+      ExecutorService existingExecutor = executors.get(executorName);
+      if (existingExecutor == null) {
+        ExecutorService newExecutor = getNewExecutor(isTransactional);
+        executors.put(executorName, newExecutor);
+        return newExecutor;
+      }
+      return existingExecutor;
+    }
+  }
+
+  private ExecutorService getNewExecutor(boolean isTransactional) {
+    if (isTransactional) {
+      return Executors.newSingleThreadExecutor();
+    } else {
+      ThreadPoolExecutor threadPoolExecutor =
+          new ThreadPoolExecutor(
+              0, maximumPoolSize, keepAliveSeconds, TimeUnit.SECONDS, new SynchronousQueue<>());
+      threadPoolExecutor.setRejectedExecutionHandler(executeInFallback);
+      return threadPoolExecutor;
+    }
+  }
+
+  private final RejectedExecutionHandler executeInFallback =
+      (r, executor) -> {
+        if (executor.isShutdown() || executor.isTerminated() || executor.isTerminating()) {
+          return;
+        }
+        ExecutorService fallbackExecutor = getTransactionalExecutor();
+        fallbackExecutor.execute(r);
+      };
+
+  public String getExecutorName(boolean isTransactional, String identifier) {
+    if (isTransactional) {
+      return name + "TransactionalExecutor" + identifier;
+    }
+    return name + "Executor" + identifier;
+  }
+
+  public void shutdown() {
+    synchronized (executors) {
+      List<String> existingExecutorNames = new ArrayList<>(executors.keySet());
+      for (String executorName : existingExecutorNames) {
+        if (!executorName.startsWith(name)) {
+          executors.remove(executorName);
+        } else {
+          removeExecutor(executorName);
+        }
+      }
+    }
+  }
+
+  public void removeExecutor(String executorName) {
+    synchronized (executors) {
+      ExecutorService existingExecutor = executors.get(executorName);
+      if (existingExecutor != null) {
+        existingExecutor.shutdownNow();
+        executors.remove(executorName);
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/googlemobileads/interfaces/ContextProvider.java

@@ -0,0 +1,30 @@
+package io.invertase.googlemobileads.interfaces;
+
+/*
+ * 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.Context;
+import com.facebook.react.bridge.ReactContext;
+
+public interface ContextProvider {
+  Activity getActivity();
+
+  ReactContext getContext();
+
+  Context getApplicationContext();
+}

package/android/src/main/java/io/invertase/googlemobileads/interfaces/NativeError.java

@@ -0,0 +1,28 @@
+package io.invertase.googlemobileads.interfaces;
+
+/*
+ * 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.WritableMap;
+
+public interface NativeError {
+  String getErrorCode();
+
+  String getErrorMessage();
+
+  WritableMap getUserInfo();
+}

package/android/src/main/java/io/invertase/googlemobileads/interfaces/NativeEvent.java

@@ -0,0 +1,26 @@
+package io.invertase.googlemobileads.interfaces;
+
+/*
+ * 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.WritableMap;
+
+public interface NativeEvent {
+  String getEventName();
+
+  WritableMap getEventBody();
+}

package/babel.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  env: {
+    test: {
+      presets: [
+        [
+          '@babel/preset-env',
+          {
+            targets: {
+              node: 'current',
+            },
+          },
+        ],
+        'module:./node_modules/metro-react-native-babel-preset',
+      ],
+    },
+  },
+  plugins: [['@babel/plugin-proposal-private-property-in-object', { loose: true }]],
+};

package/docs/displaying-ads.mdx

@@ -0,0 +1,319 @@
+# Displaying Ads
+
+The AdMob package allows you to display three types of adverts; Interstitial, Rewarded & Banner.
+
+## App Open Ads
+
+App open ads are a special ad format intended for publishers wishing to monetize their app load screens.
+App open ads can be closed by your users at any time. App open ads can be shown when users bring your app to the foreground.
+
+App open ads are shown when your application launches or when users bring your application to the foreground.
+To make sure you have an ad ready to display when a user opens your app, you'll want to have a reference to an ad ready to use.
+
+That means you must preload a app open ad before you need to show the ad. That way, your app open ad is ready to show the next time the app is opened.
+
+To create a new app open ad, call the `createForAdRequest` method from the `AppOpenAd` class. The first argument
+of the method is the "Ad Unit ID". For testing, we can use a Test ID, however for production the ID from the
+Google AdMob dashboard under "Ad units" should be used:
+
+```js
+import { AppOpenAd, TestIds, AdEventType } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.APP_OPEN : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+const appOpenAd = AppOpenAd.createForAdRequest(adUnitId, {
+  requestNonPersonalizedAdsOnly: true,
+  keywords: ['fashion', 'clothing'],
+});
+
+// Preload an app open ad
+appOpenAd.load()
+
+// Show the app open ad when user brings the app to the foreground.
+appOpenAd.show()
+
+```
+
+### Consider ad expiration
+
+Key Point: Ad references in the app open beta will time out after four hours.
+Ads rendered more than four hours after request time will no longer be valid and may not earn revenue.
+This time limit is being carefully considered and may change in future beta versions of the app open format.
+
+### Cold starts and loading screens
+
+The above documentation assumes that you only show app open ads when users foreground your app when it is suspended in memory.
+"Cold starts" occur when your app is launched but was not previously suspended in memory.
+
+An example of a cold start is when a user opens your app for the first time.
+With cold starts, you won't have a previously loaded app open ad that's ready to be shown right away.
+The delay between when you request an ad and receive an ad back can create a situation where users are able to briefly use your app before being surprised by an out of context ad.
+This should be avoided because it is a bad user experience.
+
+The preferred way to use app open ads on cold starts is to use a loading screen to load your game or app assets, and to only show the ad from the loading screen.
+If your app has completed loading and has sent the user to the main content of your app, do not show the ad.
+
+### Best practices
+
+Google built app open ads to help you monetize your app's loading screen, but it's important to keep best practices in mind so that your users enjoy using your app. Make sure to:
+
+- Wait to show your first app open ad until after your users have used your app a few times.
+- Show app open ads during times when your users would otherwise be waiting for your app to load.
+- If you have a loading screen under the app open ad, and your loading screen completes loading before the ad is dismissed, you may want to dismiss your loading screen after receiving the `onAdClosed` event.
+
+## Interstitial Ads
+
+Interstitials are full-screen ads that cover the interface of an app until closed by the user. These type of ads are
+programmatically loaded and then shown at a suitable point during your application flow (e.g. after a level on a gaming
+app has been completed, or game over). The ads can be preloaded in the background to ensure they're ready to go when needed.
+
+To create a new interstitial, call the `createForAdRequest` method from the `InterstitialAd` class. The first argument
+of the method is the "Ad Unit ID". For testing, we can use a Test ID, however for production the ID from the
+Google AdMob dashboard under "Ad units" should be used:
+
+```js
+import { InterstitialAd, TestIds, AdEventType } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.INTERSTITIAL : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+const interstitial = InterstitialAd.createForAdRequest(adUnitId, {
+  requestNonPersonalizedAdsOnly: true,
+  keywords: ['fashion', 'clothing'],
+});
+```
+
+The second argument is additional optional request options object to be sent whilst loading an advert, such as keywords & location.
+Setting additional request options helps AdMob choose better tailored ads from the network. View the [`RequestOptions`](/reference/admob/requestoptions)
+documentation to view the full range of options available.
+
+The call to `createForAdRequest` returns an instance of the [`InterstitialAd`](/reference/admob/interstitialad) class,
+which provides a number of utilities for loading and displaying interstitials.
+
+To listen to events, such as when the advert from the network has loaded or when an error occurs, we can subscribe via the
+`onAdEvent` method:
+
+```jsx
+import React, { useEffect, useState } from 'react';
+import { Button } from 'react-native';
+import { InterstitialAd, AdEventType, TestIds } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.INTERSTITIAL : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+const interstitial = InterstitialAd.createForAdRequest(adUnitId, {
+  requestNonPersonalizedAdsOnly: true,
+  keywords: ['fashion', 'clothing'],
+});
+
+function App() {
+  const [loaded, setLoaded] = useState(false);
+
+  useEffect(() => {
+    const eventListener = interstitial.onAdEvent(type => {
+      if (type === AdEventType.LOADED) {
+        setLoaded(true);
+      }
+    });
+
+    // Start loading the interstitial straight away
+    interstitial.load();
+
+    // Unsubscribe from events on unmount
+    return () => {
+      eventListener();
+    };
+  }, []);
+
+  // No advert ready to show yet
+  if (!loaded) {
+    return null;
+  }
+
+  return (
+    <Button
+      title="Show Interstitial"
+      onPress={() => {
+        interstitial.show();
+      }}
+    />
+  );
+}
+```
+
+The code above subscribes to the interstitial events (via `onAdEvent()`) and immediately starts to load a new advert from
+the network (via `load()`). Once an advert is available, local state is set, re-rendering the component showing a `Button`.
+When pressed, the `show` method on the interstitial instance is called and the advert is shown over-the-top of your
+application.
+
+The `onAdEvent` listener also triggers when events inside of the application occur, such as if the user clicks the advert,
+or closes the advert and returns back to your app. To view a full list of events which are available, view the
+[`AdEventType`](/reference/admob/adeventtype) documentation.
+
+If needed, you can reuse the existing instance of the `InterstitialAd` class to load more adverts and show them when required.
+
+## Rewarded Ads
+
+Rewarded Ads are full-screen ads that cover the interface of an app until closed by the user. The content of a rewarded
+advert is controlled via the Google AdMob dashboard.
+
+The purpose of a rewarded ad is to reward users with _something_ after completing an action inside of the advert, such
+as watching a video or submitting an option via an interactive form. If the user completes the action, you can reward them
+with something (e.g. in-game currency).
+
+To create a new interstitial, call the `createForAdRequest` method from the `RewardedAd` class. The first argument
+of the method is the "Ad Unit ID". For testing, we can use a Test ID, however for production the ID from the
+Google AdMob dashboard under "Ad units" should be used:
+
+```js
+import { RewardedAd, TestIds } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.REWARDED : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+const rewarded = RewardedAd.createForAdRequest(adUnitId, {
+  requestNonPersonalizedAdsOnly: true,
+  keywords: ['fashion', 'clothing'],
+});
+```
+
+The second argument is additional optional request options object to be sent whilst loading an advert, such as keywords & location.
+Setting additional request options helps AdMob choose better tailored ads from the network. View the [`RequestOptions`](/reference/admob/requestoptions)
+documentation to view the full range of options available.
+
+The call to `createForAdRequest` returns an instance of the [`RewardedAd`](/reference/admob/rewardedad) class,
+which provides a number of utilities for loading and displaying rewarded ads.
+
+To listen to events, such as when the advert from the network has loaded or when an error occurs, we can subscribe via the
+`onAdEvent` method:
+
+```js
+import React, { useEffect, useState } from 'react';
+import { Button } from 'react-native';
+import { RewardedAd, RewardedAdEventType, TestIds } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.REWARDED : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+const rewarded = RewardedAd.createForAdRequest(adUnitId, {
+  requestNonPersonalizedAdsOnly: true,
+  keywords: ['fashion', 'clothing'],
+});
+
+function App() {
+  const [loaded, setLoaded] = useState(false);
+
+  useEffect(() => {
+    const eventListener = rewarded.onAdEvent((type, error, reward) => {
+      if (type === RewardedAdEventType.LOADED) {
+        setLoaded(true);
+      }
+
+      if (type === RewardedAdEventType.EARNED_REWARD) {
+        console.log('User earned reward of ', reward);
+      }
+    });
+
+    // Start loading the rewarded ad straight away
+    rewarded.load();
+
+    // Unsubscribe from events on unmount
+    return () => {
+      eventListener();
+    };
+  }, []);
+
+  // No advert ready to show yet
+  if (!loaded) {
+    return null;
+  }
+
+  return (
+    <Button
+      title="Show Rewarded Ad"
+      onPress={() => {
+        rewarded.show();
+      }}
+    />
+  );
+}
+```
+
+The code above subscribes to the rewarded ad events (via `onAdEvent()`) and immediately starts to load a new advert from
+the network (via `load()`). Once an advert is available, local state is set, re-rendering the component showing a `Button`.
+When pressed, the `show` method on the rewarded ad instance is called and the advert is shown over-the-top of your
+application.
+
+Like Interstitial Ads, the events returns from the `onAdEvent` listener trigger when the user clicks the advert or closes
+the advert and returns back to your app. However, an extra `EARNED_REWARD` event can be triggered if the user completes the
+advert action. An additional `reward` property is sent with the event, containing the amount and type of rewarded (specified via the dashboard).
+An additional `reward` property is sent with the event, containing the amount and type of rewarded (specified via the dashboard).
+
+To learn more, view the [`RewardedAdEventType`](/reference/admob/rewardedadeventtype) documentation.
+
+If needed, you can reuse the existing instance of the `RewardedAd` class to load more adverts and show them when required.
+
+While the `EARNED_REWARD` event only occurs on the client, Server Side Verification (or SSV) can be used for confirming a user completed an advert action. For this, you have to specify the Server Side Verification callback URL in your Ads dashboard.
+
+You can customize SSV parameters when your SSV callback is called by setting the `serverSideVerificationOptions` field in your [`RequestOptions`](/reference/admob/requestoptions) parameter.
+
+```js
+const rewardedAd = RewardedAd.createForAdRequest(adUnitId, {
+  serverSideVerificationOptions: {
+    userId: '9999',
+    customData: 'my-custom-data',
+  },
+});
+```
+
+If you request an Advert as in the example above, AdMob will call your server with the `userId` and `customData` fields as shown below:
+
+```
+[14/Aug/2020 12:51:43] "GET /views/admob-ssv/?ad_network=...&ad_unit=...&custom_data=my-custom-data&reward_amount=1&reward_item=test_reward_item&timestamp=1597377102267&transaction_id=148cc85...&user_id=9999&signature=MEUCIQCQSi3cQ2PlxlEAkpN...&key_id=3335... HTTP/1.1" 200 0
+```
+
+You still need to verify these incoming requests yourself to ensure they are genuine. To learn more about callback parameters and verifying, see the [AdMob SDK Server Side Verification(SSV) documentation](https://developers.google.com/admob/android/rewarded-video-ssv).
+
+## Banner Ads
+
+Banner ads are partial adverts which can be integrated within your existing application. Unlike Interstitial and Rewarded Ads,
+a Banner only takes up a limited area of the application and displays an advert within the area. This allows you to integrate
+adverts without a disruptive action.
+
+The module exposes a [`BannerAd`](/reference/admob/bannerad) component. The `unitId` and `size` props are required to display
+a banner:
+
+```js
+import React from 'react';
+import { BannerAd, BannerAdSize, TestIds } from 'react-native-google-mobile-ads';
+
+const adUnitId = __DEV__ ? TestIds.BANNER : 'ca-app-pub-xxxxxxxxxxxxx/yyyyyyyyyyyyyy';
+
+function App() {
+  return (
+    <BannerAd
+      unitId={adUnitId}
+      size={BannerAdSize.FULL_BANNER}
+      requestOptions={{
+        requestNonPersonalizedAdsOnly: true,
+      }}
+    />
+  );
+}
+```
+
+The `size` prop takes a [`BannerAdSize`](/reference/admob/banneradsize) type, and once the advert is available, will
+fill the space for the chosen size.
+
+> If no inventory for the size specified is available, an error will be thrown via `onAdFailedToLoad`!
+
+The `requestOptions` prop is additional optional request options object to be sent whilst loading an advert, such as keywords & location.
+Setting additional request options helps AdMob choose better tailored ads from the network. View the [`RequestOptions`](/reference/admob/requestoptions)
+documentation to view the full range of options available.
+
+The component also exposes props for listening to events, which you can use to handle the state of your app is the user
+or network triggers an event:
+
+- `onAdClosed`
+- `onAdFailedToLoad`
+- `onAdLeftApplication`
+- `onAdOpened`
+
+Each render of the component loads a single advert, allowing you to display multiple adverts at once. If you need to reload/change
+an advert for a currently mounted component, you'll need to force a re-render inside of your own code.