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

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsCommon.mm

@@ -0,0 +1,248 @@
+//
+/**
+ * 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 "RNGoogleMobileAdsCommon.h"
+#import "common/RNRCTEventEmitter.h"
+
+NSString *const GOOGLE_MOBILE_ADS_EVENT_APP_OPEN = @"google_mobile_ads_app_open_event";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_INTERSTITIAL = @"google_mobile_ads_interstitial_event";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_REWARDED = @"google_mobile_ads_rewarded_event";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_REWARDED_INTERSTITIAL =
+    @"google_mobile_ads_rewarded_interstitial_event";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_LOADED = @"loaded";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_ERROR = @"error";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_OPENED = @"opened";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_CLICKED = @"clicked";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_CLOSED = @"closed";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_APP_EVENT = @"app_event";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_REWARDED_LOADED = @"rewarded_loaded";
+NSString *const GOOGLE_MOBILE_ADS_EVENT_REWARDED_EARNED_REWARD = @"rewarded_earned_reward";
+
+@implementation RNGADInterstitial : GADInterstitialAd
+- (void)setRequestId:(NSNumber *)requestId {
+  _requestId = requestId;
+}
+@end
+
+@implementation RNGADRewarded : GADRewardedAd
+- (void)setRequestId:(NSNumber *)requestId {
+  _requestId = requestId;
+}
+@end
+
+@implementation RNGoogleMobileAdsCommon
+
++ (GAMRequest *)buildAdRequest:(NSDictionary *)adRequestOptions {
+  GAMRequest *request = [GAMRequest request];
+  NSMutableDictionary *extras = [@{} mutableCopy];
+
+  if (adRequestOptions[@"requestNonPersonalizedAdsOnly"] &&
+      [adRequestOptions[@"requestNonPersonalizedAdsOnly"] boolValue]) {
+    extras[@"npa"] = @"1";
+  }
+
+  if (adRequestOptions[@"networkExtras"]) {
+    for (NSString *key in adRequestOptions[@"networkExtras"]) {
+      NSString *value = adRequestOptions[@"networkExtras"][key];
+      extras[key] = value;
+    }
+  }
+
+  if (adRequestOptions[@"publisherProvidedSignals"]) {
+    NSDictionary *pps = adRequestOptions[@"publisherProvidedSignals"];
+    for (NSString *key in pps) {
+      extras[key] = pps[key];
+    }
+  }
+
+  GADExtras *networkExtras = [[GADExtras alloc] init];
+  networkExtras.additionalParameters = extras;
+  [request registerAdNetworkExtras:networkExtras];
+
+  if (adRequestOptions[@"keywords"]) {
+    request.keywords = adRequestOptions[@"keywords"];
+  }
+
+  if (adRequestOptions[@"contentUrl"]) {
+    request.contentURL = adRequestOptions[@"contentUrl"];
+  }
+
+  if (adRequestOptions[@"requestAgent"]) {
+    request.requestAgent = adRequestOptions[@"requestAgent"];
+  }
+
+  if (adRequestOptions[@"customTargeting"]) {
+    request.customTargeting = adRequestOptions[@"customTargeting"];
+  }
+
+  if (adRequestOptions[@"publisherProvidedId"]) {
+    request.publisherProvidedID = adRequestOptions[@"publisherProvidedId"];
+  }
+
+  return request;
+}
+
++ (NSDictionary *)getCodeAndMessageFromAdError:(NSError *)error {
+  NSString *code = @"unknown";
+  NSString *message = [error localizedDescription];
+
+  if (error.code == GADErrorInvalidRequest) {
+    code = @"invalid-request";
+  } else if (error.code == GADErrorNoFill) {
+    code = @"no-fill";
+  } else if (error.code == GADErrorNetworkError) {
+    code = @"network-error";
+  } else if (error.code == GADErrorServerError) {
+    code = @"server-error";
+  } else if (error.code == GADErrorTimeout) {
+    code = @"timeout";
+  } else if (error.code == GADErrorMediationDataError) {
+    code = @"mediation-data-error";
+  } else if (error.code == GADErrorMediationAdapterError) {
+    code = @"mediation-adapter-error";
+  } else if (error.code == GADErrorMediationInvalidAdSize) {
+    code = @"mediation-invalid-ad-size";
+  } else if (error.code == GADErrorInternalError) {
+    code = @"internal-error";
+  } else if (error.code == GADErrorInvalidArgument) {
+    code = @"invalid-argument";
+  } else if (error.code == GADErrorReceivedInvalidAdString) {
+    code = @"received-invalid-ad-string";
+  } else if (error.code == GADErrorAdAlreadyUsed) {
+    code = @"ad-already-used";
+  } else if (error.code == GADErrorApplicationIdentifierMissing) {
+    code = @"application-identifier-missing";
+  }
+
+  return @{
+    @"code" : code,
+    @"message" : message,
+  };
+}
+
++ (void)sendAdEvent:(NSString *)event
+          requestId:(NSNumber *)requestId
+               type:(NSString *)type
+           adUnitId:(NSString *)adUnitId
+              error:(nullable NSDictionary *)error
+               data:(nullable NSDictionary *)data {
+  NSMutableDictionary *body = [@{
+    @"type" : type,
+  } mutableCopy];
+
+  if (error != nil) {
+    body[@"error"] = error;
+  }
+
+  if (data != nil) {
+    body[@"data"] = data;
+  }
+
+  NSMutableDictionary *payload = [@{
+    @"eventName" : type,
+    @"requestId" : requestId,
+    @"adUnitId" : adUnitId,
+    @"body" : body,
+  } mutableCopy];
+
+  [[RNRCTEventEmitter shared] sendEventWithName:event body:payload];
+}
+
++ (GADAdSize)stringToAdSize:(NSString *)value
+              withMaxHeight:(CGFloat)maxHeight
+                   andWidth:(CGFloat)adWidth {
+  NSError *error = nil;
+  NSRegularExpression *regex =
+      [NSRegularExpression regularExpressionWithPattern:@"([0-9]+)x([0-9]+)"
+                                                options:0
+                                                  error:&error];
+  NSArray *matches = [regex matchesInString:value options:0 range:NSMakeRange(0, [value length])];
+
+  for (NSTextCheckingResult *match in matches) {
+    NSString *matchText = [value substringWithRange:[match range]];
+    if (matchText) {
+      NSArray *values = [matchText componentsSeparatedByString:@"x"];
+      CGFloat width = (CGFloat)[values[0] intValue];
+      CGFloat height = (CGFloat)[values[1] intValue];
+      return GADAdSizeFromCGSize(CGSizeMake(width, height));
+    }
+  }
+
+  value = [value uppercaseString];
+
+  if ([value isEqualToString:@"BANNER"]) {
+    return GADAdSizeBanner;
+  } else if ([value isEqualToString:@"FLUID"]) {
+    return GADAdSizeFluid;
+  } else if ([value isEqualToString:@"WIDE_SKYSCRAPER"]) {
+    return GADAdSizeSkyscraper;
+  } else if ([value isEqualToString:@"LARGE_BANNER"]) {
+    return GADAdSizeLargeBanner;
+  } else if ([value isEqualToString:@"MEDIUM_RECTANGLE"]) {
+    return GADAdSizeMediumRectangle;
+  } else if ([value isEqualToString:@"FULL_BANNER"]) {
+    return GADAdSizeFullBanner;
+  } else if ([value isEqualToString:@"LEADERBOARD"]) {
+    return GADAdSizeLeaderboard;
+  } else if ([value isEqualToString:@"ANCHORED_ADAPTIVE_BANNER"] ||
+             [value isEqualToString:@"LARGE_ANCHORED_ADAPTIVE_BANNER"] ||
+             [value isEqualToString:@"INLINE_ADAPTIVE_BANNER"]) {
+    CGRect frame = [[UIScreen mainScreen] bounds];
+    if (@available(iOS 11.0, *)) {
+      frame =
+          UIEdgeInsetsInsetRect(frame, [UIApplication sharedApplication].keyWindow.safeAreaInsets);
+    }
+    CGFloat viewWidth = adWidth > 0 ? MIN(frame.size.width, adWidth) : frame.size.width;
+    if ([value isEqualToString:@"INLINE_ADAPTIVE_BANNER"]) {
+      if (maxHeight > 0) {
+        return GADInlineAdaptiveBannerAdSizeWithWidthAndMaxHeight(viewWidth, MAX(maxHeight, 32.0));
+      }
+      return GADCurrentOrientationInlineAdaptiveBannerAdSizeWithWidth(viewWidth);
+    }
+    if ([value isEqualToString:@"LARGE_ANCHORED_ADAPTIVE_BANNER"]) {
+      return GADLargeAnchoredAdaptiveBannerAdSizeWithWidth(viewWidth);
+    }
+    return GADCurrentOrientationAnchoredAdaptiveBannerAdSizeWithWidth(viewWidth);
+  } else {
+    return GADAdSizeBanner;
+  }
+}
+
++ (BOOL)isAdManagerUnit:(NSString *)unitId {
+  if (unitId == nil) {
+    return NO;
+  }
+  return [unitId hasPrefix:@"/"];
+}
+
++ (UIViewController *)currentViewController {
+  UIViewController *controller = [[[UIApplication sharedApplication] keyWindow] rootViewController];
+  UIViewController *presentedController = controller.presentedViewController;
+
+  while (presentedController && ![presentedController isBeingDismissed]) {
+    controller = presentedController;
+    presentedController = controller.presentedViewController;
+  }
+  return controller;
+}
+
+@end
+
+#endif

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsConsentModule.h

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

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsConsentModule.mm

@@ -0,0 +1,356 @@
+//
+/**
+ * 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 <React/RCTConvert.h>
+#if !TARGET_OS_MACCATALYST
+#include <UserMessagingPlatform/UserMessagingPlatform.h>
+#endif
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNGoogleMobileAdsSpec.h"
+#endif
+#import "RNGoogleMobileAdsConsentModule.h"
+#import "common/RNSharedUtils.h"
+
+@implementation RNGoogleMobileAdsConsentModule
+#pragma mark -
+#pragma mark Module Setup
+
+RCT_EXPORT_MODULE();
+
+- (dispatch_queue_t)methodQueue {
+  return dispatch_get_main_queue();
+}
+
+#pragma mark -
+#pragma mark Google Mobile Ads Methods
+
+#if !TARGET_OS_MACCATALYST
+- (NSString *)getConsentStatusString:(UMPConsentStatus)consentStatus {
+  switch (consentStatus) {
+    case UMPConsentStatusRequired:
+      return @"REQUIRED";
+    case UMPConsentStatusNotRequired:
+      return @"NOT_REQUIRED";
+    case UMPConsentStatusObtained:
+      return @"OBTAINED";
+    case UMPConsentStatusUnknown:
+    default:
+      return @"UNKNOWN";
+  }
+}
+#endif
+
+#if !TARGET_OS_MACCATALYST
+- (NSString *)getPrivacyOptionsRequirementStatusString:
+    (UMPPrivacyOptionsRequirementStatus)privacyOptionsRequirementStatus {
+  switch (privacyOptionsRequirementStatus) {
+    case UMPPrivacyOptionsRequirementStatusRequired:
+      return @"REQUIRED";
+    case UMPPrivacyOptionsRequirementStatusNotRequired:
+      return @"NOT_REQUIRED";
+    case UMPPrivacyOptionsRequirementStatusUnknown:
+    default:
+      return @"UNKNOWN";
+  }
+}
+#endif
+
+#if !TARGET_OS_MACCATALYST
+- (NSDictionary *)getConsentInformation {
+  return @{
+    @"status" : [self getConsentStatusString:UMPConsentInformation.sharedInstance.consentStatus],
+    @"canRequestAds" : @(UMPConsentInformation.sharedInstance.canRequestAds),
+    @"privacyOptionsRequirementStatus" :
+        [self getPrivacyOptionsRequirementStatusString:UMPConsentInformation.sharedInstance
+                                                           .privacyOptionsRequirementStatus],
+    @"isConsentFormAvailable" :
+        @(UMPConsentInformation.sharedInstance.formStatus == UMPFormStatusAvailable)
+  };
+}
+#endif
+
+RCT_EXPORT_METHOD(requestInfoUpdate
+                  : (NSDictionary *)options
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+#if !TARGET_OS_MACCATALYST
+  UMPRequestParameters *parameters = [[UMPRequestParameters alloc] init];
+  UMPDebugSettings *debugSettings = [[UMPDebugSettings alloc] init];
+
+  debugSettings.geography =
+      (UMPDebugGeography)([options[@"debugGeography"] integerValue] ?: UMPDebugGeographyDisabled);
+  debugSettings.testDeviceIdentifiers =
+      [options valueForKeyPath:@"testDeviceIdentifiers"] ?: [[NSMutableArray alloc] init];
+
+  parameters.debugSettings = debugSettings;
+  parameters.tagForUnderAgeOfConsent = [options[@"tagForUnderAgeOfConsent"] boolValue] ?: FALSE;
+
+  [UMPConsentInformation.sharedInstance
+      requestConsentInfoUpdateWithParameters:parameters
+                           completionHandler:^(NSError *_Nullable error) {
+                             if (error) {
+                               [RNSharedUtils
+                                   rejectPromiseWithUserInfo:reject
+                                                    userInfo:[@{
+                                                      @"code" : @"consent-update-failed",
+                                                      @"message" : error.localizedDescription,
+                                                    } mutableCopy]];
+                             } else {
+                               resolve([self getConsentInformation]);
+                             }
+                           }];
+#endif
+}
+
+RCT_EXPORT_METHOD(showForm : (RCTPromiseResolveBlock)resolve : (RCTPromiseRejectBlock)reject) {
+  [self showForm:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(showPrivacyOptionsForm
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self showPrivacyOptionsForm:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(loadAndShowConsentFormIfRequired
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self loadAndShowConsentFormIfRequired:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(reset) {
+#if !TARGET_OS_MACCATALYST
+  [UMPConsentInformation.sharedInstance reset];
+#endif
+}
+
+RCT_EXPORT_METHOD(getConsentInfo
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self getConsentInfo:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getTCString : (RCTPromiseResolveBlock)resolve : (RCTPromiseRejectBlock)reject) {
+  [self getTCString:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getGdprApplies
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self getGdprApplies:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getPurposeConsents
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self getPurposeConsents:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(getPurposeLegitimateInterests
+                  : (RCTPromiseResolveBlock)resolve
+                  : (RCTPromiseRejectBlock)reject) {
+  [self getPurposeLegitimateInterests:resolve reject:reject];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeConsentModuleSpecJSI>(params);
+}
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)requestInfoUpdate:(JS::NativeConsentModule::AdsConsentInfoOptions &)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  UMPRequestParameters *parameters = [[UMPRequestParameters alloc] init];
+  UMPDebugSettings *debugSettings = [[UMPDebugSettings alloc] init];
+
+  debugSettings.geography =
+      static_cast<UMPDebugGeography>(options.debugGeography().value_or(UMPDebugGeographyDisabled));
+  debugSettings.testDeviceIdentifiers = options.testDeviceIdentifiers().has_value()
+      ? ^{
+          NSMutableArray *array = [[NSMutableArray alloc] init];
+          FB::LazyVector<NSString *, id> identifiers = options.testDeviceIdentifiers().value();
+          for (int i = 0; i < identifiers.size(); i++) {
+              [array addObject:identifiers[i]];  // Direct access by index
+          }
+          return array;
+      }()
+      : [[NSMutableArray alloc] init];
+
+  parameters.debugSettings = debugSettings;
+  parameters.tagForUnderAgeOfConsent = options.tagForUnderAgeOfConsent().value_or(FALSE);
+
+  [UMPConsentInformation.sharedInstance
+      requestConsentInfoUpdateWithParameters:parameters
+                           completionHandler:^(NSError *_Nullable error) {
+                             if (error) {
+                               [RNSharedUtils
+                                   rejectPromiseWithUserInfo:reject
+                                                    userInfo:[@{
+                                                      @"code" : @"consent-update-failed",
+                                                      @"message" : error.localizedDescription,
+                                                    } mutableCopy]];
+                             } else {
+                               resolve([self getConsentInformation]);
+                             }
+                           }];
+#endif
+}
+#endif
+
+- (void)showForm:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  [UMPConsentForm loadWithCompletionHandler:^(UMPConsentForm *form, NSError *loadError) {
+    if (loadError) {
+      [RNSharedUtils rejectPromiseWithUserInfo:reject
+                                      userInfo:[@{
+                                        @"code" : @"consent-form-error",
+                                        @"message" : loadError.localizedDescription,
+                                      } mutableCopy]];
+    } else {
+      [form presentFromViewController:[UIApplication sharedApplication]
+                                          .delegate.window.rootViewController
+                    completionHandler:^(NSError *_Nullable dismissError) {
+                      if (dismissError) {
+                        [RNSharedUtils
+                            rejectPromiseWithUserInfo:reject
+                                             userInfo:[@{
+                                               @"code" : @"consent-form-error",
+                                               @"message" : dismissError.localizedDescription,
+                                             } mutableCopy]];
+                      } else {
+                        resolve([self getConsentInformation]);
+                      }
+                    }];
+    }
+  }];
+#endif
+}
+
+- (void)showPrivacyOptionsForm:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  [UMPConsentForm
+      presentPrivacyOptionsFormFromViewController:[UIApplication sharedApplication]
+                                                      .delegate.window.rootViewController
+                                completionHandler:^(NSError *_Nullable formError) {
+                                  if (formError) {
+                                    [RNSharedUtils
+                                        rejectPromiseWithUserInfo:reject
+                                                         userInfo:[@{
+                                                           @"code" : @"privacy-options-form-error",
+                                                           @"message" :
+                                                               formError.localizedDescription,
+                                                         } mutableCopy]];
+                                  } else {
+                                    resolve([self getConsentInformation]);
+                                  }
+                                }];
+#endif
+}
+
+- (void)loadAndShowConsentFormIfRequired:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  [UMPConsentForm
+      loadAndPresentIfRequiredFromViewController:[UIApplication sharedApplication]
+                                                     .delegate.window.rootViewController
+                               completionHandler:^(NSError *_Nullable formError) {
+                                 if (formError) {
+                                   [RNSharedUtils
+                                       rejectPromiseWithUserInfo:reject
+                                                        userInfo:[@{
+                                                          @"code" : @"consent-form-error",
+                                                          @"message" :
+                                                              formError.localizedDescription,
+                                                        } mutableCopy]];
+                                 } else {
+                                   resolve([self getConsentInformation]);
+                                 }
+                               }];
+#endif
+}
+
+- (void)getConsentInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+#if !TARGET_OS_MACCATALYST
+  resolve([self getConsentInformation]);
+#endif
+}
+
+- (void)getTCString:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    // https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20CMP%20API%20v2.md#in-app-details
+    NSString *tcString = [[NSUserDefaults standardUserDefaults] objectForKey:@"IABTCF_TCString"];
+    resolve(tcString);
+  } @catch (NSError *error) {
+    [RNSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:[@{
+                                      @"code" : @"consent-string-error",
+                                      @"message" : error.localizedDescription,
+                                    } mutableCopy]];
+  }
+}
+
+- (void)getGdprApplies:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    BOOL gdprApplies = [[NSUserDefaults standardUserDefaults] boolForKey:@"IABTCF_gdprApplies"];
+    resolve(@(gdprApplies));
+  } @catch (NSError *error) {
+    [RNSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:[@{
+                                      @"code" : @"consent-string-error",
+                                      @"message" : error.localizedDescription,
+                                    } mutableCopy]];
+  }
+}
+
+- (void)getPurposeConsents:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    NSString *purposeConsents =
+        [[NSUserDefaults standardUserDefaults] stringForKey:@"IABTCF_PurposeConsents"];
+    resolve(purposeConsents);
+  } @catch (NSError *error) {
+    [RNSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:[@{
+                                      @"code" : @"consent-string-error",
+                                      @"message" : error.localizedDescription,
+                                    } mutableCopy]];
+  }
+}
+
+- (void)getPurposeLegitimateInterests:(RCTPromiseResolveBlock)resolve
+                               reject:(RCTPromiseRejectBlock)reject {
+  @try {
+    NSString *purposeLegitimateInterests =
+        [[NSUserDefaults standardUserDefaults] stringForKey:@"IABTCF_PurposeLegitimateInterests"];
+    resolve(purposeLegitimateInterests);
+  } @catch (NSError *error) {
+    [RNSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:[@{
+                                      @"code" : @"consent-string-error",
+                                      @"message" : error.localizedDescription,
+                                    } mutableCopy]];
+  }
+}
+
+@end

package/ios/RNGoogleMobileAds/RNGoogleMobileAdsFullScreenAd.h

@@ -0,0 +1,53 @@
+/**
+ * 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 <Foundation/Foundation.h>
+#import <GoogleMobileAds/GoogleMobileAds.h>
+#import "RNGoogleMobileAdsFullScreenContentDelegate.h"
+#import "RNSharedUtils.h"
+
+@interface RNGoogleMobileAdsFullScreenAd : NSObject
+
+@property(nonatomic, strong) NSMutableDictionary<NSNumber *, id<GADFullScreenPresentingAd>> *adMap;
+@property(nonatomic, strong)
+    NSMutableDictionary<NSNumber *, RNGoogleMobileAdsFullScreenContentDelegate *> *delegateMap;
+
+- (instancetype)init;
+- (void)invalidate;
+- (NSString *)getAdEventName;
+- (void)loadAd:(NSString *)adUnitId
+            adRequest:(GAMRequest *)adRequest
+    completionHandler:(void (^)(id<GADFullScreenPresentingAd> ad, NSError *error))completionHandler;
+- (void)sendAdEvent:(NSString *)type
+          requestId:(int)requestId
+           adUnitId:(NSString *)adUnitId
+              error:(NSDictionary *)error
+               data:(NSDictionary *)data;
+- (void)loadWithRequestId:(int)requestId
+                 adUnitId:(NSString *)adUnitId
+         adRequestOptions:(NSDictionary *)adRequestOptions;
+- (void)showWithRequestId:(int)requestId
+                 adUnitId:(NSString *)adUnitId
+              showOptions:(NSDictionary *)showOptions
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject;
+
+@end
+
+#endif