react-native-google-mobile-ads 4.1.0

package/docs/european-user-consent.mdx

@@ -0,0 +1,258 @@
+# European User Consent
+
+Under the Google [EU User Consent Policy](https://www.google.com/about/company/consentstaging.html), you must make
+certain disclosures to your users in the European Economic Area (EEA) and obtain their consent to use cookies or
+other local storage, where legally required, and to use personal data (such as `AdID`) to serve ads. This policy
+reflects the requirements of the `EU ePrivacy Directive` and the `General Data Protection Regulation` (GDPR).
+
+The React Native Google Mobile Ads module provides out of the box support for helping to manage your users consent
+within your application. The `AdsConsent` helper which comes with the module wraps the Google Consent SDK for both
+Android & iOS, and provides a single JavaScript interface for both platforms.
+
+The `AdsConsent` helper & AdMob module provides out of the box support for:
+
+- Requesting consent for multiple publisher IDs.
+- Showing a Google-rendered consent form, listing all providers on your enabled mediation networks.
+- Manually handling user consent if you prefer not to use the Google-rendered consent form.
+- Forwarding your user consent status onto AdMob ad requests.
+
+## Understanding AdMob Ads
+
+Ads served by Google can be categorized as personalized or non-personalized, both requiring consent from users in the EEA. By default,
+ad requests to Google serve personalized ads, with ad selection based on the user's previously collected data. Users outside of the EEA do not require consent.
+
+> The `AdsConsent` helper only provides you with the tools for requesting consent, it is up to the developer to ensure the consent status is reflected throughout the app.
+
+## Handling consent
+
+The following steps show the various methods and ways of handling consent within your app.
+
+### Delaying app measurement
+
+By default, the Google Mobile Ads SDK initializes app measurement and begins sending user-level event data to Google immediately when the app starts.
+If your app will be used by users within the EEA, it is important you prevent app measurement until your first ad has been requested (after consent).
+
+Within your projects `app.json` file, set the `delay_app_measurement_init` to `true` to delay app measurement:
+
+```json
+{
+  "react-native-google-mobile-ads": {
+    "android_app_id": "ca-app-pub-xxxxxxxx~xxxxxxxx",
+    "ios_app_id": "ca-app-pub-xxxxxxxx~xxxxxxxx",
+    "delay_app_measurement_init": true
+  }
+}
+```
+
+Once set, rebuild your application:
+
+```bash
+# For iOS
+npx react-native run-ios
+
+# For Android
+npx react-native run-android
+```
+
+### Requesting consent information
+
+It is recommended you request consent information each time your application starts. The Consent SDK stores the users consent status
+based on the state of your AdMob network. If the state changes (e.g. a new mediation provider is added) the SDK automatically
+invalidates the consent status (setting is to "UNKNOWN").
+
+The `AdsConsent` helper provides a promised based method to return the users consent status called `requestInfoUpdate`. This method
+accepts an array of publisher IDs, which are used by the Consent SDK to determine the users consent status.
+
+Your own publisher ID can be found on the [Google AdMob dashboard](https://apps.admob.com/v2/settings) under "Settings > Account Information":
+
+![Publisher ID](https://prismic-io.s3.amazonaws.com/invertase%2Fbcb7e7d6-2bb3-4e8c-8e6e-be99d6bc4f56_new+project+%2816%29.jpg)
+
+To request consent, call the method as early as possible within your app before presenting any ads:
+
+```js
+import { AdsConsent } from 'react-native-google-mobile-ads';
+
+const consentInfo = await AdsConsent.requestInfoUpdate(['pub-6189033257628123']);
+```
+
+The result of the method returns an `AdsConsentInfo` interface, which provides information about the users status and location:
+
+- **status**: The status can be one of 3 outcomes:
+  - `UNKNOWN`: The user has not yet given consent, or has been invalidated since the last time they gave consent.
+  - `NON_PERSONALIZED`: The user gave consent to see non-personalized ads only.
+  - `PERSONALIZED`: The user gave consent to see personalized ads.
+- **isRequestLocationInEeaOrUnknown**: A boolean value. If `true` the users location is within the EEA or is unknown.
+
+The combination of status and location allows you to handle the next steps for requesting consent, if required:
+
+1. If the users location is within the EEA or unknown, and their status is unknown, you must request consent before showing any ads.
+2. If the users location is within the EEA or unknown, and their status is **not** unknown, you can show only the ad personalization they have requested.
+3. If the users location is outside of the EEA, you do not have to give consent.
+
+### Gathering user consent
+
+Now we understand the consent status of the user, we can gather their consent (if required). This can be done in two ways:
+
+1. Using a Google-rendered consent form.
+2. Using a custom method.
+
+If you are aware that users are under the age of consent in Europe, it is possible to set this using the `setTagForUnderAgeOfConsent`
+method (TFUA). Once the setting is enabled, the Google-rendered consent form will fail to load. All ad requests that include
+TFUA will be made ineligible for personalized advertising and remarketing. TFUA disables requests to third-party ad technology
+providers, such as ad measurement pixels and third-party ad servers.
+
+To remove this setting, pass `false` to the method.
+
+#### 1. Google-rendered consent form
+
+The Google-rendered consent form is a full-screen configurable form that displays over your app content.
+You can configure the form to present the user with combinations of the following options:
+
+- Consent to view personalized ads
+- Consent to view non-personalized ads
+- Use a paid version of the app instead of viewing ads
+
+You should review the consent text carefully: what appears by default is a message that might be appropriate if you use
+Google to monetize your app; but Google cannot provide legal advice on the consent text that is appropriate for you.
+To update consent text of the Google-rendered consent form, modify the `consentform.html` file included in the Consent SDK as required.
+
+> An [example of a Google-rendered](https://developers.google.com/admob/images/android_eu_consent_form.png) consent form.
+
+To show the consent form, the `AdsConsent` helper provides a `showForm` method, which takes options to configure the form.
+You must provide a privacy policy URL.
+
+```js
+import { AdsConsent, AdsConsentStatus } from 'react-native-google-mobile-ads';
+
+const consentInfo = await AdsConsent.requestInfoUpdate(['pub-6189033257628123']);
+
+if (
+  consentInfo.isRequestLocationInEeaOrUnknown &&
+  consentInfo.status === AdsConsentStatus.UNKNOWN
+) {
+  const formResult = await AdsConsent.showForm({
+    privacyPolicy: 'https://invertase.io/privacy-policy',
+    withPersonalizedAds: true,
+    withNonPersonalizedAds: true,
+    withAdFree: true,
+  });
+}
+```
+
+Once the user has selected their preference, the `formResult` contains their status and whether or not they prefer an
+ad-free option of your application (if enabled):
+
+```js
+const formResult = await AdsConsent.showForm({
+  privacyPolicy: 'https://invertase.io/privacy-policy',
+  withPersonalizedAds: true,
+  withNonPersonalizedAds: true,
+  withAdFree: true,
+});
+
+if (formResult.userPrefersAdFree) {
+  // Handle the users request, e.g. redirect to a paid for version of the app
+}
+
+// The user requested non-personalized or personalized ads
+const status = formResult.status;
+```
+
+The `formResult.status` provides feedback on whether the user consented to personalized ads, or non-personalized ads.
+It is important that you forward this status onto all ad requests (see below).
+
+> Do not persist the status. You could however store this locally in application state (e.g. React Context) and update the status on every app launch as it may change.
+
+#### 2. Custom consent method
+
+If you wish to implement your own consent flow, the `AdsConsent` helper provides the tools needed to accomplish this.
+Depending on your requirements, a list of the enabled network mediation providers for the AdMob App ID can be returned and shown
+to the user via the `getAdProviders` method:
+
+```js
+import { AdsConsent } from 'react-native-google-mobile-ads';
+
+const providers = await AdsConsent.getAdProviders();
+```
+
+Each provider is an interface of `AdProvider`, containing information such as their company ID, company name and privacy policy URL.
+Using this information you can request consent from your users.
+
+Once consent has been returned, the Consent SDK needs to be aware of the custom user consent status. This can be forwarded on using the
+`setStatus` method, for example:
+
+```js
+import { AdsConsent, AdsConsentStatus } from 'react-native-google-mobile-ads';
+
+// After getting user consent...
+await AdsConsent.setStatus(AdsConsentStatus.PERSONALIZED);
+```
+
+To invalidate the users consent status (e.g. if the providers list changes since their last consent), set the status back to
+`UNKNOWN`. When your application next boots, you can get the users previous consent status using the `getStatus` method.
+
+### Testing
+
+When developing the consent flow, the behavior of the `AdsConsent` responses may not be reliable due to the environment
+(e.g. using an emulator vs real device). It is possible to set a debug location to test the various responses from the
+Consent SDK.
+
+If using a real device, ensure you whitelist it using the device ID, which can be obtained from native logs or using a library
+such as [react-native-device-info](https://github.com/react-native-community/react-native-device-info). Once found,
+call the `addTestDevice(deviceId)` method.
+
+> Emulators are automatically whitelisted.
+
+To set a debug location, use the `setDebugGeography` method. It accepts 3 values:
+
+- **DISABLED**: Removes any previous debug locations.
+- **EEA**: Set the test device to be within the EEA.
+- **NOT_EEA**: Set the test device to be outside of the EEA.
+
+For example:
+
+```js
+import { AdsConsent, AdsConsentDebugGeography } from 'react-native-google-mobile-ads';
+
+await AdsConsent.setDebugGeography(AdsConsentDebugGeography.EEA);
+```
+
+> Always ensure debug information is removed for production apps!
+
+### Forwarding the consent status to ads
+
+Assuming the user is within the EEA and has provided consent, their status needs to be forwarded to every ad request we
+make in our application.
+
+> If the user is within the EEA and has not given consent, do not display AdMob ads (even non-personalized).
+
+Taking a Rewarded Video as an example, we can apply the users consent when our ad is loaded via the `RequestOptions`. For example:
+
+```js
+import { AdsConsent, RewardedAd } from 'react-native-google-mobile-ads';
+
+const status = await AdsConsent.getStatus();
+
+const rewardedAd = RewardedAd.createForAdRequest('AD_UNIT_ID', {
+  requestNonPersonalizedAdsOnly: status === AdsConsentStatus.NON_PERSONALIZED,
+});
+```
+
+The requested ad URL via the SDK will send a request with an additional parameter `&npa=1`, which will return a
+non-personalized ad.
+
+### Troubleshooting
+
+#### "Could not parse Event FE preflight response."
+
+This is a common error which occurs on both Android & iOS when making a request to display a Google-rendered consent form. Unfortunately the reasoning for this error is generic, making it hard to debug. There are a number of steps to check which are usually the cause for this error:
+
+- The AdMob App ID is incorrect: Ensure you have entered the correct ID into the `app.json` file under the `android_app_id` or `ios_app_id` key in the `react-native-google-mobile-ads` config.
+- A publisher ID is incorrect: Ensure your entered publisher IDs are correct.
+  - The publisher ID needs to be available on the same account as your AdMob App ID.
+- The user is outside of the EEA: If a user does not need to provide consent, the form request will error. Ensure you have checked the users status via `requestInfoUpdate`. If using an emulator, ensure you set a debug location via `setDebugGeography`.
+- Your AdMob account is not valid:
+  - Your account is disabled: This can occur if Google notices you have duplicate accounts. They will email you about this, and block you from entering the dashboard.
+  - You have provided invalid payment information: If your account has no payment information set up, this seems to cause this error to trigger.
+
+If you are still struggling to present the consent form, reach out to AdMob support to investigate your account status via https://support.google.com/admob

package/docs/img/logo_admob_192px.svg

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 22.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Content" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="192px" height="192px" viewBox="0 0 192 192" enable-background="new 0 0 192 192" xml:space="preserve">
+<rect id="bounding_box_2_" fill="none" width="192" height="192"/>
+<g id="logo_x5F_admob_x5F_192px">
+	<g id="icon_x5F_admob_x5F_192px_2_">
+		<path fill="#FBBC04" d="M92.01,8.26C93.28,8,98.31,8.01,99.51,8c34.25-0.27,81.75,28.87,84.49,84.28v69.18
+			c0,12.45-10.28,22.54-22.77,22.54c-9,0-21.23-11.53-21.23-22.5V92.32c-1.27-18.26-16.07-38.81-40.99-40.36
+			c-1.54-0.1-5.04-0.16-7.01,0.1"/>
+		<path fill="#4285F4" d="M183.98,162c0,12.15-9.85,22-22,22S140,174.15,140,162c0-12.15,9.83-22,21.98-22S183.98,149.85,183.98,162
+			z"/>
+		<path fill="#EA4335" d="M93.2,183.24c12.6,0,22.81-10.02,22.81-22.37c0-12.36-10.46-21.33-23.05-21.33
+			c-0.08,0-0.16,0.01-0.24,0.01c-21.66-1.5-41.92-20.57-40.44-46.71c0,0,0.01-0.13,0.03-0.42c1.25-20.51,18.75-39.12,40.9-40.4l0,0
+			c0,0,0,0,0,0c12.6,0,22.81-9.04,22.81-21.39S105.8,8.25,93.2,8.25c-0.51,0-1.02-0.03-1.53,0C53.46,9.58,8.46,41.37,8.01,95.4v0.33
+			c0,54.83,48.09,87.5,83.93,87.5H93.2z"/>
+	</g>
+</g>
+</svg>

package/docs/index.mdx

@@ -0,0 +1,168 @@
+# Installation
+
+```bash
+# Install the admob module
+yarn add react-native-google-mobile-ads
+```
+
+> On Android, before releasing your app, you must select _Yes, my app contains ads_ in the Google Play Store, Policy, App content, Manage under Ads.
+
+# What does it do
+
+The AdMob module allows you to display adverts to your users. All adverts are served over the Google AdMob network, meaning
+a [Google AdMob account](https://apps.admob.com) is required.
+
+<YouTube id="9qCxo0D-Sak" />
+
+The module supports three types of Ads:
+
+1. Full screen [App Open Ads](/displaying-ads#app-open-ads).
+2. Full screen [Interstitial Ads](/displaying-ads#interstitial-ads).
+3. Full screen [Rewarded Ads](/displaying-ads#rewarded-ads).
+4. Component based [Banner Ads](/displaying-ads#banner-ads).
+
+# Getting Started
+
+A number of steps must be taken and considered before you start serving adverts to your users:
+
+- [Installation](#installation)
+- [Getting Started](#getting-started)
+  - [Setting up Google AdMob](#setting-up-google-admob)
+  - [Configure outbound requests](#configure-outbound-requests)
+  - [European User Consent](#european-user-consent)
+  - [Test ads](#test-ads)
+- [Next Steps](#next-steps)
+
+## Setting up Google AdMob
+
+Before you are able to display ads to your users, you must have a [Google AdMob account](https://apps.admob.com). Under the
+"Apps" menu item, create or choose an existing Android/iOS app. Each app platform exposes a unique account ID which needs to
+be added to the project.
+
+> Attempting to build your app without a valid App ID may cause a crash during build.
+
+Under the "App settings" menu item, you can find the "App ID":
+
+![Google AdMob App ID](https://prismic-io.s3.amazonaws.com/invertase%2F52dd6900-108c-47a6-accb-699fde963b99_new+project+%2813%29.jpg)
+
+Within the root of your React Native project, open the `app.json` file and add the
+`android_app_id` & `ios_app_id` keys with the IDs from the Google AdMob console:
+
+```json
+// <project-root>/app.json
+{
+  "react-native-google-mobile-ads": {
+    "android_app_id": "ca-app-pub-xxxxxxxx~xxxxxxxx",
+    "ios_app_id": "ca-app-pub-xxxxxxxx~xxxxxxxx"
+  }
+}
+```
+
+For the changes to take effect, rebuild your project:
+
+```bash
+# For iOS
+cd ios/ && pod install
+npx react-native run-ios
+
+# For Android
+npx react-native run-android
+```
+
+## Configure outbound requests
+
+If the default ad settings are not correct for your app, you can provide settings that will apply to all ad requests.
+
+For example, if the application targets children then you must configure the outbound requests to only
+receive content suitable for children before loading any adverts.
+
+If you need to set a custom request configuration, you must call the `setRequestConfiguration` method before initializing the Google Mobile Ads SDK:
+
+```js
+import mobileAds, { MaxAdContentRating } from 'react-native-google-mobile-ads';
+
+mobileAds()
+  .setRequestConfiguration({
+    // Update all future requests suitable for parental guidance
+    maxAdContentRating: MaxAdContentRating.PG,
+
+    // Indicates that you want your content treated as child-directed for purposes of COPPA.
+    tagForChildDirectedTreatment: true,
+
+    // Indicates that you want the ad request to be handled in a
+    // manner suitable for users under the age of consent.
+    tagForUnderAgeOfConsent: true,
+
+    // An array of test device IDs to whitelist.
+    testDeviceIdentifiers: ["EMULATOR"];
+  })
+  .then(() => {
+    // Request config successfully set!
+  });
+```
+
+To learn more about the request configuration settings, view the [`RequestConfiguration`](/reference/admob/requestconfiguration) documentation.
+
+## Initialize the Google Mobile Ads SDK
+
+Before loading ads, have your app initialize the Google Mobile Ads SDK by calling `initialize` which initializes the SDK and returns a promise once initialization is complete (or after a 30-second timeout).
+This needs to be done only once, ideally at app launch.
+
+> ⚠️ **Warning:** Ads may be preloaded by the Mobile Ads SDK or mediation partner SDKs upon calling `initialize`.
+If you need to obtain consent from users in the European Economic Area (EEA), set any request-specific flags (such as tagForChildDirectedTreatment), or otherwise take action before loading ads, ensure you do so before initializing the Mobile Ads SDK.
+
+```js
+import mobileAds from 'react-native-google-mobile-ads';
+
+mobileAds()
+  .initialize()
+  .then((adapterStatuses) => {
+    // Initialization complete!
+  });
+```
+
+If you are using mediation, you may wish to wait until the promise is settled before loading ads, as this will ensure that all mediation adapters are initialized.
+
+## European User Consent
+
+Out of the box, AdMob does not handle any related regulations which you may need to enforce on your application.
+It is up to the developer to implement and handle this on a user-by-user basis. You must consent to EEA users
+being served both personalized and non-personalized adverts before showing them. For more information, see
+[Requesting Consent from European Users](https://developers.google.com/admob/android/eu-consent).
+
+The AdMob module provides a `AdConsent` helper to help developers quickly implement consent flows within their application.
+See the [European User Consent page](/european-user-consent) for full examples of how to integrate the helper into your application.
+
+## Test ads
+
+Whilst developing your app with AdMob, you'll want to make sure you use test ads rather than production ads from your
+Google AdMob account - otherwise your account may be disabled!
+
+Although usage of different advert types is explained later, when creating your adverts the "Ad Unit ID" being used whilst
+testing can be set to a testing ID. The code snippet below shows how to initialize each advert type with a test ID:
+
+```jsx
+import { AppOpenAd, InterstitialAd, RewardedAd, BannerAd, TestIds } from 'react-native-google-mobile-ads';
+
+# App Open
+AppOpenAd.createForAdRequest(TestIds.APP_OPEN);
+
+# Interstitial
+InterstitialAd.createForAdRequest(TestIds.INTERSTITIAL);
+
+# Rewarded
+RewardedAd.createForAdRequest(TestIds.REWARDED);
+
+# Banners
+<BannerAd unitId={TestIds.BANNER} />
+```
+
+# Next Steps
+
+Now the basics of setting up and configuring AdMob have been explained, we can go ahead and start to display different
+adverts to our users. The AdMob module provides integration with three different types:
+
+- [App Open Ads](/displaying-ads#app-open-ads)
+- [Interstitial Ads](/displaying-ads#interstitial-ads)
+- [Rewarded Ads](/displaying-ads#rewarded-ads)
+- [Banner Ads](/displaying-ads#banner-ads)

package/docs.json

@@ -0,0 +1,9 @@
+{
+  "name": "React Native Google Mobile Ads",
+  "twitter": "invertaseio",
+  "sidebar": [
+    ["Installation", "/"],
+    ["Displaying Ads", "/displaying-ads"],
+    ["European User Consent", "/european-user-consent"]
+  ]
+} 

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsAppOpenModule.h

@@ -0,0 +1,29 @@
+/**
+ * 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 <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import "RNGoogleMobileAdsFullScreenContentDelegate.h"
+
+@import GoogleMobileAds;
+
+@interface RNGoogleMobileAdsAppOpenModule : NSObject <RCTBridgeModule>
+
+@property(strong, nonatomic) GADAppOpenAd* appOpenAd;
+@property(strong, nonatomic) RNGoogleMobileAdsFullScreenContentDelegate* appOpenDelegate;
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsAppOpenModule.m

@@ -0,0 +1,98 @@
+/**
+ * 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/RCTUtils.h>
+
+#import "RNGoogleMobileAdsAppOpenModule.h"
+#import "RNGoogleMobileAdsCommon.h"
+#import "common/RNSharedUtils.h"
+
+@implementation RNGoogleMobileAdsAppOpenModule
+#pragma mark -
+#pragma mark Module Setup
+
+RCT_EXPORT_MODULE();
+
+- (dispatch_queue_t)methodQueue {
+  return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+// #pragma mark -
+// #pragma mark Google Mobile Ads Methods
+
+RCT_EXPORT_METHOD(appOpenLoad
+                  : (nonnull NSNumber *)requestId
+                  : (NSString *)adUnitId
+                  : (NSDictionary *)adRequestOptions) {
+  self.appOpenAd = nil;
+  GADRequest *request = [GADRequest request];
+  [GADAppOpenAd loadWithAdUnitID:adUnitId
+                         request:request
+                     orientation:UIInterfaceOrientationPortrait
+               completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
+                 if (error) {
+                   NSDictionary *codeAndMessage =
+                       [RNGoogleMobileAdsCommon getCodeAndMessageFromAdError:error];
+                   [RNGoogleMobileAdsCommon sendAdEvent:GOOGLE_MOBILE_ADS_EVENT_APP_OPEN
+                                              requestId:requestId
+                                                   type:GOOGLE_MOBILE_ADS_EVENT_ERROR
+                                               adUnitId:adUnitId
+                                                  error:codeAndMessage
+                                                   data:nil];
+                   return;
+                 }
+                 self.appOpenAd = appOpenAd;
+                 RNGoogleMobileAdsFullScreenContentDelegate *fullScreenContentDelegate =
+                     [[RNGoogleMobileAdsFullScreenContentDelegate alloc] init];
+                 fullScreenContentDelegate.sendAdEvent = GOOGLE_MOBILE_ADS_EVENT_APP_OPEN;
+                 fullScreenContentDelegate.requestId = requestId;
+                 fullScreenContentDelegate.adUnitId = adUnitId;
+                 self.appOpenAd.fullScreenContentDelegate = fullScreenContentDelegate;
+                 self.appOpenDelegate = fullScreenContentDelegate;
+                 [RNGoogleMobileAdsCommon sendAdEvent:GOOGLE_MOBILE_ADS_EVENT_APP_OPEN
+                                            requestId:requestId
+                                                 type:GOOGLE_MOBILE_ADS_EVENT_LOADED
+                                             adUnitId:adUnitId
+                                                error:nil
+                                                 data:nil];
+               }];
+}
+
+RCT_EXPORT_METHOD(appOpenShow
+                  : (nonnull NSNumber *)requestId
+                  : (NSDictionary *)showOptions
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  if (self.appOpenAd) {
+    [self.appOpenAd
+        presentFromRootViewController:RCTSharedApplication().delegate.window.rootViewController];
+    resolve([NSNull null]);
+  } else {
+    [RNSharedUtils
+        rejectPromiseWithUserInfo:reject
+                         userInfo:[@{
+                           @"code" : @"not-ready",
+                           @"message" : @"App Open ad attempted to show but was not ready.",
+                         } mutableCopy]];
+  }
+}
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsBannerViewManager.h

@@ -0,0 +1,23 @@
+//
+/**
+ * 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/RCTViewManager.h>
+
+@interface RNGoogleMobileAdsBannerViewManager : RCTViewManager
+
+@end