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

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsModule.h

@@ -0,0 +1,32 @@
+/**
+ * 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>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <RNGoogleMobileAdsSpec/RNGoogleMobileAdsSpec.h>
+@interface RNGoogleMobileAdsModule : NSObject <NativeGoogleMobileAdsModuleSpec>
+
+#else
+
+#import <React/RCTBridgeModule.h>
+@interface RNGoogleMobileAdsModule : NSObject <RCTBridgeModule>
+
+#endif
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsModule.mm

@@ -0,0 +1,180 @@
+/**
+ * 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.
+ *
+ */
+
+#if !TARGET_OS_MACCATALYST
+#import <GoogleMobileAds/GoogleMobileAds.h>
+#endif
+#import <React/RCTUtils.h>
+
+#import "RNGoogleMobileAdsModule.h"
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNGoogleMobileAdsSpec.h"
+#endif
+#import "common/RNSharedUtils.h"
+
+@implementation RNGoogleMobileAdsModule
+#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(initialize : (RCTPromiseResolveBlock)resolve : (RCTPromiseRejectBlock)reject) {
+  [self initialize:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(setRequestConfiguration
+                  : (NSDictionary *)requestConfiguration
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self setRequestConfiguration:requestConfiguration resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(openAdInspector
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self openAdInspector:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(openDebugMenu : (NSString *)adUnit) {
+#if !TARGET_OS_MACCATALYST
+  GADDebugOptionsViewController *debugOptionsViewController =
+      [GADDebugOptionsViewController debugOptionsViewControllerWithAdUnitID:adUnit];
+  [RCTSharedApplication().delegate.window.rootViewController
+      presentViewController:debugOptionsViewController
+                   animated:YES
+                 completion:nil];
+#endif
+}
+
+RCT_EXPORT_METHOD(setAppVolume : (double)volume) {
+#if !TARGET_OS_MACCATALYST
+  GADMobileAds.sharedInstance.applicationVolume = volume;
+#endif
+}
+
+RCT_EXPORT_METHOD(setAppMuted : (BOOL)muted) {
+#if !TARGET_OS_MACCATALYST
+  GADMobileAds.sharedInstance.applicationMuted = muted;
+#endif
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeGoogleMobileAdsModuleSpecJSI>(params);
+}
+#endif
+
+- (void)initialize:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  [[GADMobileAds sharedInstance]
+      startWithCompletionHandler:^(GADInitializationStatus *_Nonnull status) {
+        NSDictionary *adapterStatuses = [status adapterStatusesByClassName];
+        NSMutableArray *result = [[NSMutableArray alloc] init];
+        for (NSString *adapter in adapterStatuses) {
+          GADAdapterStatus *adapterStatus = adapterStatuses[adapter];
+          NSDictionary *dict = @{
+            @"name" : adapter,
+            @"state" : @(adapterStatus.state),
+            @"description" : adapterStatus.description
+          };
+          [result addObject:dict];
+        }
+        resolve(result);
+      }];
+#endif
+}
+
+- (void)setRequestConfiguration:(NSDictionary *)requestConfiguration
+                        resolve:(RCTPromiseResolveBlock)resolve
+                         reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  if (requestConfiguration[@"maxAdContentRating"]) {
+    NSString *rating = requestConfiguration[@"maxAdContentRating"];
+    if ([rating isEqualToString:@"G"]) {
+      GADMobileAds.sharedInstance.requestConfiguration.maxAdContentRating =
+          GADMaxAdContentRatingGeneral;
+    } else if ([rating isEqualToString:@"PG"]) {
+      GADMobileAds.sharedInstance.requestConfiguration.maxAdContentRating =
+          GADMaxAdContentRatingParentalGuidance;
+    } else if ([rating isEqualToString:@"T"]) {
+      GADMobileAds.sharedInstance.requestConfiguration.maxAdContentRating =
+          GADMaxAdContentRatingTeen;
+    } else if ([rating isEqualToString:@"MA"]) {
+      GADMobileAds.sharedInstance.requestConfiguration.maxAdContentRating =
+          GADMaxAdContentRatingMatureAudience;
+    }
+  }
+
+  if (requestConfiguration[@"tagForChildDirectedTreatment"]) {
+    BOOL tag = [requestConfiguration[@"tagForChildDirectedTreatment"] boolValue];
+    GADMobileAds.sharedInstance.requestConfiguration.tagForChildDirectedTreatment =
+        [NSNumber numberWithBool:tag];
+  }
+
+  if (requestConfiguration[@"tagForUnderAgeOfConsent"]) {
+    BOOL tag = [requestConfiguration[@"tagForUnderAgeOfConsent"] boolValue];
+    GADMobileAds.sharedInstance.requestConfiguration.tagForUnderAgeOfConsent =
+        [NSNumber numberWithBool:tag];
+  }
+
+  if (requestConfiguration[@"testDeviceIdentifiers"]) {
+    NSMutableArray *devices = [@[] mutableCopy];
+    for (NSString *key in requestConfiguration[@"testDeviceIdentifiers"]) {
+      [devices addObject:key];
+    }
+    GADMobileAds.sharedInstance.requestConfiguration.testDeviceIdentifiers = devices;
+  }
+
+  resolve([NSNull null]);
+#endif
+}
+
+- (void)openAdInspector:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  [GADMobileAds.sharedInstance
+      presentAdInspectorFromViewController:RCTSharedApplication().delegate.window.rootViewController
+                         completionHandler:^(NSError *_Nullable error) {
+                           if (error != nil) {
+                             [RNSharedUtils
+                                 rejectPromiseWithUserInfo:reject
+                                                  userInfo:[@{
+                                                    @"code" : [NSString
+                                                        stringWithFormat:@"CODE_%ld",
+                                                                         static_cast<long>(
+                                                                             error.code)],
+                                                    @"message" : error.description,
+                                                  } mutableCopy]];
+                           } else {
+                             resolve(nil);
+                           }
+                         }];
+#endif
+}
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsNativeModule.h

@@ -0,0 +1,35 @@
+/**
+ * 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 <GoogleMobileAds/GADAdLoader.h>
+#import <GoogleMobileAds/GADNativeAd.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNGoogleMobileAdsSpec/RNGoogleMobileAdsSpec.h>
+
+@interface RNGoogleMobileAdsNativeModule
+    : NativeGoogleMobileAdsNativeModuleSpecBase <NativeGoogleMobileAdsNativeModuleSpec>
+#else
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RNGoogleMobileAdsNativeModule : RCTEventEmitter <RCTBridgeModule>
+#endif
+
+- (GADNativeAd *)nativeAdForResponseId:(NSString *)responseId;
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsNativeModule.mm

@@ -0,0 +1,321 @@
+/**
+ * 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.
+ *
+ */
+
+#if !TARGET_OS_MACCATALYST
+
+#import "RNGoogleMobileAdsNativeModule.h"
+#import "RNGoogleMobileAdsCommon.h"
+
+typedef void (^RNGMANativeAdLoadCompletionHandler)(GADNativeAd *_Nullable nativeAd,
+                                                   NSError *_Nullable error);
+
+@interface RNGMANativeAdHolder
+    : NSObject <GADNativeAdLoaderDelegate, GADNativeAdDelegate, GADVideoControllerDelegate>
+
+@property(strong, nullable) GADNativeAd *nativeAd;
+
+- (instancetype)initWithNativeModule:(RNGoogleMobileAdsNativeModule *)nativeModule
+                            adUnitId:(NSString *)adUnitId
+                      requestOptions:(NSDictionary *)requestOptions;
+
+- (void)loadWithCompletionHandler:(RNGMANativeAdLoadCompletionHandler)completionHandler;
+
+- (void)dispose;
+
+@end
+
+@implementation RNGoogleMobileAdsNativeModule {
+  NSMutableDictionary<NSString *, RNGMANativeAdHolder *> *_adHolders;
+}
+
+RCT_EXPORT_MODULE();
+
+- (dispatch_queue_t)methodQueue {
+  return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeGoogleMobileAdsNativeModuleSpecJSI>(params);
+}
+#else
+- (NSArray<NSString *> *)supportedEvents {
+  return @[ @"RNGMANativeAdEvent" ];
+}
+#endif
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _adHolders = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+RCT_EXPORT_METHOD(
+    load
+    : (NSString *)adUnitId requestOptions
+    : (NSDictionary *)requestOptions resolve
+    : (RCTPromiseResolveBlock)resolve reject
+    : (RCTPromiseRejectBlock)reject {
+      RNGMANativeAdHolder *adHolder =
+          [[RNGMANativeAdHolder alloc] initWithNativeModule:self
+                                                   adUnitId:adUnitId
+                                             requestOptions:requestOptions];
+
+      [adHolder loadWithCompletionHandler:^(GADNativeAd *nativeAd, NSError *error) {
+        if (error != nil) {
+          reject(@"ERROR_LOAD", error.description, error);
+          return;
+        }
+
+        NSString *responseId = nativeAd.responseInfo.responseIdentifier;
+        if (responseId == nil) {
+          reject(@"ERROR_LOAD", @"Failed to get a valid response ID from the loaded ad.", nil);
+          return;
+        }
+
+        [_adHolders setValue:adHolder forKey:responseId];
+
+        resolve(@{
+          @"responseId" : responseId,
+          @"advertiser" : nativeAd.advertiser ?: [NSNull null],
+          @"body" : nativeAd.body ?: [NSNull null],
+          @"callToAction" : nativeAd.callToAction ?: [NSNull null],
+          @"headline" : nativeAd.headline ?: [NSNull null],
+          @"price" : nativeAd.price ?: [NSNull null],
+          @"store" : nativeAd.store ?: [NSNull null],
+          @"starRating" : nativeAd.starRating ?: [NSNull null],
+          @"icon" : (nativeAd.icon && nativeAd.icon.imageURL != nil)
+              ? @{@"scale" : @(nativeAd.icon.scale), @"url" : nativeAd.icon.imageURL.absoluteString}
+              : [NSNull null],
+          @"mediaContent" : @{
+            @"aspectRatio" : @(nativeAd.mediaContent.aspectRatio),
+            @"hasVideoContent" : @(nativeAd.mediaContent.hasVideoContent),
+            @"duration" : @(nativeAd.mediaContent.duration)
+          }
+        });
+      }];
+    })
+
+RCT_EXPORT_METHOD(destroy
+                  : (NSString *)responseId {
+                    if (responseId) {
+                      [[_adHolders valueForKey:responseId] dispose];
+                      [_adHolders removeObjectForKey:responseId];
+                    }
+                  });
+
+- (GADNativeAd *)nativeAdForResponseId:(NSString *)responseId {
+  return [_adHolders valueForKey:responseId].nativeAd;
+}
+
+- (void)dealloc {
+  NSArray *adHolders = [_adHolders allValues];
+  for (RNGMANativeAdHolder *adHolder in adHolders) {
+    [adHolder dispose];
+  }
+  [_adHolders removeAllObjects];
+}
+
+@end
+
+#pragma mark - RNGMANativeAdHolder
+
+@implementation RNGMANativeAdHolder {
+  __weak RNGoogleMobileAdsNativeModule *_nativeModule;
+  GADAdLoader *_adLoader;
+  GAMRequest *_adRequest;
+  RNGMANativeAdLoadCompletionHandler _completionHandler;
+}
+
+- (instancetype)initWithNativeModule:(RNGoogleMobileAdsNativeModule *)nativeModule
+                            adUnitId:(NSString *)adUnitId
+                      requestOptions:(NSDictionary *_Nonnull)requestOptions {
+  if (self = [super init]) {
+    _nativeModule = nativeModule;
+
+    GADNativeAdImageAdLoaderOptions *imageOptions = [[GADNativeAdImageAdLoaderOptions alloc] init];
+    //    imageOptions.disableImageLoading = YES;
+    GADNativeAdMediaAdLoaderOptions *mediaOptions = [[GADNativeAdMediaAdLoaderOptions alloc] init];
+    if (requestOptions[@"aspectRatio"]) {
+      switch ([requestOptions[@"aspectRatio"] intValue]) {
+        case 1:
+          mediaOptions.mediaAspectRatio = GADMediaAspectRatioAny;
+          break;
+        case 2:
+          mediaOptions.mediaAspectRatio = GADMediaAspectRatioLandscape;
+          break;
+        case 3:
+          mediaOptions.mediaAspectRatio = GADMediaAspectRatioPortrait;
+          break;
+        case 4:
+          mediaOptions.mediaAspectRatio = GADMediaAspectRatioSquare;
+          break;
+      }
+    }
+    GADNativeAdViewAdOptions *adViewOptions = [[GADNativeAdViewAdOptions alloc] init];
+    if (requestOptions[@"adChoicesPlacement"]) {
+      switch ([requestOptions[@"adChoicesPlacement"] intValue]) {
+        case 0:
+          adViewOptions.preferredAdChoicesPosition = GADAdChoicesPositionTopLeftCorner;
+          break;
+        case 1:
+          adViewOptions.preferredAdChoicesPosition = GADAdChoicesPositionTopRightCorner;
+          break;
+        case 2:
+          adViewOptions.preferredAdChoicesPosition = GADAdChoicesPositionBottomRightCorner;
+          break;
+        case 3:
+          adViewOptions.preferredAdChoicesPosition = GADAdChoicesPositionBottomLeftCorner;
+          break;
+      }
+    }
+    GADVideoOptions *videoOptions = [[GADVideoOptions alloc] init];
+    if (requestOptions[@"startVideoMuted"]) {
+      videoOptions.startMuted = [requestOptions[@"startVideoMuted"] boolValue];
+    }
+
+    _adLoader = [[GADAdLoader alloc]
+          initWithAdUnitID:adUnitId
+        rootViewController:[RNGoogleMobileAdsCommon currentViewController]
+                   adTypes:@[ GADAdLoaderAdTypeNative ]
+                   options:@[ imageOptions, mediaOptions, adViewOptions, videoOptions ]];
+    _adLoader.delegate = self;
+    _adRequest = [RNGoogleMobileAdsCommon buildAdRequest:requestOptions];
+  }
+  return self;
+}
+
+- (void)loadWithCompletionHandler:(RNGMANativeAdLoadCompletionHandler)completionHandler {
+  _completionHandler = completionHandler;
+  [_adLoader loadRequest:_adRequest];
+}
+
+- (void)dispose {
+  _nativeAd = nil;
+  _nativeModule = nil;
+  _adLoader = nil;
+  _adRequest = nil;
+  _completionHandler = nil;
+}
+
+#pragma mark - GADNativeAdLoaderDelegate
+
+- (void)adLoader:(nonnull GADAdLoader *)adLoader
+    didReceiveNativeAd:(nonnull GADNativeAd *)nativeAd {
+  _nativeAd = nativeAd;
+  _nativeAd.delegate = self;
+  _nativeAd.paidEventHandler = ^(GADAdValue *_Nonnull adValue) {
+    NSDictionary *revenueData = @{
+      @"value" : adValue.value,
+      @"precision" : @(adValue.precision),
+      @"currency" : adValue.currencyCode ?: @""
+    };
+    [self emitAdEvent:@"paid" withData:revenueData];
+  };
+  if (nativeAd.mediaContent.hasVideoContent) {
+    nativeAd.mediaContent.videoController.delegate = self;
+  }
+  _completionHandler(nativeAd, nil);
+  _completionHandler = nil;
+}
+
+- (void)adLoader:(nonnull GADAdLoader *)adLoader
+    didFailToReceiveAdWithError:(nonnull NSError *)error {
+  _completionHandler(nil, error);
+  _completionHandler = nil;
+}
+
+#pragma mark - GADNativeAdDelegate
+
+- (void)nativeAdDidRecordImpression:(GADNativeAd *)nativeAd {
+  [self emitAdEvent:@"impression"];
+}
+
+- (void)nativeAdDidRecordClick:(GADNativeAd *)nativeAd {
+  [self emitAdEvent:@"clicked"];
+}
+
+- (void)nativeAdWillPresentScreen:(GADNativeAd *)nativeAd {
+  [self emitAdEvent:@"opened"];
+}
+
+- (void)nativeAdWillDismissScreen:(GADNativeAd *)nativeAd {
+  // Not in use
+}
+
+- (void)nativeAdDidDismissScreen:(GADNativeAd *)nativeAd {
+  [self emitAdEvent:@"closed"];
+}
+
+- (void)nativeAdWillLeaveApplication:(GADNativeAd *)nativeAd {
+  // Not in use
+}
+
+- (void)videoControllerDidPlayVideo:(nonnull GADVideoController *)videoController {
+  [self emitAdEvent:@"video_played"];
+}
+
+- (void)videoControllerDidPauseVideo:(nonnull GADVideoController *)videoController {
+  [self emitAdEvent:@"video_paused"];
+}
+
+- (void)videoControllerDidEndVideoPlayback:(nonnull GADVideoController *)videoController {
+  [self emitAdEvent:@"video_ended"];
+}
+
+- (void)videoControllerDidMuteVideo:(nonnull GADVideoController *)videoController {
+  [self emitAdEvent:@"video_muted"];
+}
+
+- (void)videoControllerDidUnmuteVideo:(nonnull GADVideoController *)videoController {
+  [self emitAdEvent:@"video_unmuted"];
+}
+
+- (void)emitAdEvent:(nonnull NSString *)type withData:(NSDictionary *)data {
+  if (_nativeModule == nil || _nativeAd == nil) {
+    return;
+  }
+
+  NSMutableDictionary *payload = [NSMutableDictionary dictionary];
+  if (data != nil) {
+    [payload addEntriesFromDictionary:data];
+  }
+
+  NSString *responseId = _nativeAd.responseInfo.responseIdentifier;
+  payload[@"responseId"] = responseId ?: [NSNull null];
+  payload[@"type"] = type;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  [_nativeModule emitOnAdEvent:payload];
+#else
+  [_nativeModule sendEventWithName:@"RNGMANativeAdEvent" body:payload];
+#endif
+}
+
+- (void)emitAdEvent:(NSString *)type {
+  [self emitAdEvent:type withData:nil];
+}
+
+@end
+
+#endif

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsNativeView.h

@@ -0,0 +1,51 @@
+/**
+ * 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 <GoogleMobileAds/GADNativeAd.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewComponentView.h>
+#else
+#import <React/RCTView.h>
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+#ifdef RCT_NEW_ARCH_ENABLED
+@interface RNGoogleMobileAdsNativeView : RCTViewComponentView
+
+// provided by superclass, but we narrow the type in our declaration
+@property(nonatomic, strong, nullable) GADNativeAdView *contentView;
+#else
+@interface RNGoogleMobileAdsNativeView : GADNativeAdView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge;
+#endif
+
+@property(nonatomic, copy) NSString *responseId;
+
+@end
+
+#ifndef RCT_NEW_ARCH_ENABLED
+@interface RNGoogleMobileAdsNativeViewManager : RCTViewManager
+
+@end
+#endif
+
+NS_ASSUME_NONNULL_END