use promises instead of callbacks for request and show (iOS)

koenpunt · koenpunt · commit f18e1e98d113 · 2017-08-02T12:53:28.000+02:00
diff --git a/Example/index.js b/Example/index.js
@@ -59,16 +59,16 @@ export default class Example extends Component {
     AdMobRewarded.addEventListener('rewardedVideoDidClose',
       () => {
         console.log('rewardedVideoDidClose');
-        AdMobRewarded.requestAd((error) => error && console.log(error));
+        AdMobRewarded.requestAd().catch(error => console.log(error));
       }
     );
     AdMobRewarded.addEventListener('rewardedVideoWillLeaveApplication',
       () => console.log('rewardedVideoWillLeaveApplication')
     );
 
-    AdMobRewarded.requestAd((error) => error && console.log(error));
+    AdMobRewarded.requestAd().catch(error => console.log(error));
 
-    AdMobInterstitial.setTestDevices([AdMobRewarded.simulatorId]);
+    AdMobInterstitial.setTestDevices([AdMobInterstitial.simulatorId]);
     AdMobInterstitial.setAdUnitID('ca-app-pub-3940256099942544/4411468910');
 
     AdMobInterstitial.addEventListener('interstitialDidLoad',
@@ -83,14 +83,14 @@ export default class Example extends Component {
     AdMobInterstitial.addEventListener('interstitialDidClose',
       () => {
         console.log('interstitialDidClose');
-        AdMobInterstitial.requestAd((error) => error && console.log(error));
+        AdMobInterstitial.requestAd().catch(error => console.log(error));
       }
     );
     AdMobInterstitial.addEventListener('interstitialWillLeaveApplication',
       () => console.log('interstitialWillLeaveApplication')
     );
 
-    AdMobInterstitial.requestAd((error) => error && console.log(error));
+    AdMobInterstitial.requestAd().catch(error => console.log(error));
   }
 
   componentWillUnmount() {
@@ -99,11 +99,11 @@ export default class Example extends Component {
   }
 
   showRewarded() {
-    AdMobRewarded.showAd((error) => error && console.log(error));
+    AdMobRewarded.showAd().catch(error => console.log(error));
   }
 
   showInterstitial() {
-    AdMobInterstitial.showAd((error) => error && console.log(error));
+    AdMobInterstitial.showAd().catch(error => console.log(error));
   }
 
   render() {
diff --git a/RNAdMobInterstitial.js b/RNAdMobInterstitial.js
@@ -9,9 +9,23 @@ const adMobInterstitialEmitter = new NativeEventEmitter(RNAdMobInterstitial);
 
 const eventHandlers = {};
 
+const createErrorFromErrorData = (errorData) => {
+  const {
+    message,
+    ...extraErrorInfo
+  } = errorData || {};
+  const error = new Error(message);
+  error.framesToPop = 1;
+  return Object.assign(error, extraErrorInfo);
+}
+
 const addEventListener = (type, handler) => {
   eventHandlers[type] = eventHandlers[type] || new Map();
-  eventHandlers[type].set(handler, adMobInterstitialEmitter.addListener(type, handler));
+  if (type === 'interstitialDidFailToLoad') {
+    eventHandlers[type].set(handler, adMobInterstitialEmitter.addListener(type, error => handler(createErrorFromErrorData(error))));
+  } else {
+    eventHandlers[type].set(handler, adMobInterstitialEmitter.addListener(type, handler));
+  }
 };
 
 const removeEventListener = (type, handler) => {
@@ -34,8 +48,6 @@ const removeAllListeners = () => {
 
 export default {
   ...RNAdMobInterstitial,
-  requestAd: (cb = () => {}) => RNAdMobInterstitial.requestAd(cb), // requestAd callback is optional
-  showAd: (cb = () => {}) => RNAdMobInterstitial.showAd(cb),       // showAd callback is optional
   addEventListener,
   removeEventListener,
   removeAllListeners,
diff --git a/RNAdMobRewarded.js b/RNAdMobRewarded.js
@@ -10,9 +10,23 @@ const adMobRewardedEmitter = new NativeEventEmitter(RNAdMobRewarded);
 
 const eventHandlers = {};
 
+const createErrorFromErrorData = (errorData) => {
+  const {
+    message,
+    ...extraErrorInfo
+  } = errorData || {};
+  const error = new Error(message);
+  error.framesToPop = 1;
+  return Object.assign(error, extraErrorInfo);
+}
+
 const addEventListener = (type, handler) => {
   eventHandlers[type] = eventHandlers[type] || new Map();
-  eventHandlers[type].set(handler, adMobRewardedEmitter.addListener(type, handler));
+  if (type === 'rewardedVideoDidFailToLoad') {
+    eventHandlers[type].set(handler, adMobRewardedEmitter.addListener(type, error => handler(createErrorFromErrorData(error))));
+  } else {
+    eventHandlers[type].set(handler, adMobRewardedEmitter.addListener(type, handler));
+  }
 };
 
 const removeEventListener = (type, handler) => {
@@ -35,8 +49,6 @@ const removeAllListeners = () => {
 
 export default {
   ...RNAdMobRewarded,
-  requestAd: (cb = () => {}) => RNAdMobRewarded.requestAd(cb), // requestAd callback is optional
-  showAd: (cb = () => {}) => RNAdMobRewarded.showAd(cb),       // showAd callback is optional
   addEventListener,
   removeEventListener,
   removeAllListeners,
diff --git a/ios/RNAdMobInterstitial.m b/ios/RNAdMobInterstitial.m
@@ -10,8 +10,8 @@ @implementation RNAdMobInterstitial {
   GADInterstitial  *_interstitial;
   NSString *_adUnitID;
   NSArray *_testDevices;
-  RCTResponseSenderBlock _requestAdCallback;
-  RCTResponseSenderBlock _showAdCallback;
+  RCTPromiseResolveBlock _requestAdResolve;
+  RCTPromiseRejectBlock _requestAdReject;
   BOOL hasListeners;
 }
 
@@ -44,32 +44,34 @@ - (dispatch_queue_t)methodQueue
   _testDevices = testDevices;
 }
 
-RCT_EXPORT_METHOD(requestAd:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(requestAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
+  _requestAdResolve = nil;
+  _requestAdReject = nil;
+
   if ([_interstitial hasBeenUsed] || _interstitial == nil) {
-    _requestAdCallback = callback;
+    _requestAdResolve = resolve;
+    _requestAdReject = reject;
 
     _interstitial = [[GADInterstitial alloc] initWithAdUnitID:_adUnitID];
-    if (hasListeners) {
-      _interstitial.delegate = self;
-    }
+    _interstitial.delegate = self;
 
     GADRequest *request = [GADRequest request];
     request.testDevices = _testDevices;
     [_interstitial loadRequest:request];
   } else {
-    callback(@[RCTMakeError(@"Ad is already loaded.", nil, nil)]);
+    reject(@"E_AD_ALREADY_LOADED", @"Ad is already loaded.", nil);
   }
 }
 
-RCT_EXPORT_METHOD(showAd:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(showAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
   if ([_interstitial isReady]) {
-    _showAdCallback = callback;
     [_interstitial presentFromRootViewController:[UIApplication sharedApplication].delegate.window.rootViewController];
+    resolve(nil);
   }
   else {
-    callback(@[RCTMakeError(@"Ad is not ready.", nil, nil)]);
+    reject(@"E_AD_NOT_READY", @"Ad is not ready.", nil);
   }
 }
 
@@ -88,50 +90,43 @@ - (dispatch_queue_t)methodQueue
 - (void)startObserving
 {
   hasListeners = YES;
-  if (_interstitial) {
-    _interstitial.delegate = self;
-  }
 }
 
 - (void)stopObserving
 {
   hasListeners = NO;
-  if (_interstitial) {
-    _interstitial.delegate = nil;
-  }
 }
 
 #pragma mark GADInterstitialDelegate
 
-- (void)interstitialDidReceiveAd:(GADInterstitial *)ad {
+- (void)interstitialDidReceiveAd:(__unused GADInterstitial *)ad {
   if (hasListeners) {
     [self sendEventWithName:@"interstitialDidLoad" body:nil];
   }
-  _requestAdCallback(@[[NSNull null]]);
+  _requestAdResolve(nil);
 }
 
-- (void)interstitial:(GADInterstitial *)interstitial
-didFailToReceiveAdWithError:(GADRequestError *)error {
+- (void)interstitial:(__unused GADInterstitial *)interstitial didFailToReceiveAdWithError:(GADRequestError *)error {
   if (hasListeners) {
-    [self sendEventWithName:@"interstitialDidFailToLoad" body:@{@"name": [error description]}];
+    NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);
+    [self sendEventWithName:@"interstitialDidFailToLoad" body:jsError];
   }
-  _requestAdCallback(@[[error description]]);
+  _requestAdReject(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);
 }
 
-- (void)interstitialWillPresentScreen:(GADInterstitial *)ad {
+- (void)interstitialWillPresentScreen:(__unused GADInterstitial *)ad {
   if (hasListeners){
     [self sendEventWithName:@"interstitialDidOpen" body:nil];
   }
-  _showAdCallback(@[[NSNull null]]);
 }
 
-- (void)interstitialDidDismissScreen:(GADInterstitial *)ad {
+- (void)interstitialDidDismissScreen:(__unused GADInterstitial *)ad {
   if (hasListeners) {
     [self sendEventWithName:@"interstitialDidClose" body:nil];
   }
 }
 
-- (void)interstitialWillLeaveApplication:(GADInterstitial *)ad {
+- (void)interstitialWillLeaveApplication:(__unused GADInterstitial *)ad {
   if (hasListeners) {
     [self sendEventWithName:@"interstitialWillLeaveApplication" body:nil];
   }
diff --git a/ios/RNAdMobRewarded.m b/ios/RNAdMobRewarded.m
@@ -9,8 +9,8 @@
 @implementation RNAdMobRewarded {
     NSString *_adUnitID;
     NSArray *_testDevices;
-    RCTResponseSenderBlock _requestAdCallback;
-    RCTResponseSenderBlock _showAdCallback;
+    RCTPromiseResolveBlock _requestAdResolve;
+    RCTPromiseRejectBlock _requestAdReject;
     BOOL hasListeners;
 }
 
@@ -45,26 +45,28 @@ - (dispatch_queue_t)methodQueue
     _testDevices = testDevices;
 }
 
-RCT_EXPORT_METHOD(requestAd:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(requestAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
-    _requestAdCallback = callback;
+    _requestAdResolve = resolve;
+    _requestAdReject = reject;
+    
     [GADRewardBasedVideoAd sharedInstance].delegate = self;
     GADRequest *request = [GADRequest request];
     request.testDevices = _testDevices;
     [[GADRewardBasedVideoAd sharedInstance] loadRequest:request
                                            withAdUnitID:_adUnitID];
 }
 
-RCT_EXPORT_METHOD(showAd:(RCTResponseSenderBlock)callback)
+RCT_EXPORT_METHOD(showAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     if ([[GADRewardBasedVideoAd sharedInstance] isReady]) {
-        _showAdCallback = callback;
         UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];
         UIViewController *rootViewController = [keyWindow rootViewController];
         [[GADRewardBasedVideoAd sharedInstance] presentFromRootViewController:rootViewController];
+        resolve(nil);
     }
     else {
-        callback(@[RCTMakeError(@"Ad is not ready", nil, nil)]);
+        reject(@"E_AD_NOT_READY", @"Ad is not ready.", nil);
     }
 }
 
@@ -83,62 +85,60 @@ - (dispatch_queue_t)methodQueue
 - (void)startObserving
 {
     hasListeners = YES;
-    [GADRewardBasedVideoAd sharedInstance].delegate = self;
 }
 
 - (void)stopObserving
 {
     hasListeners = NO;
-    [GADRewardBasedVideoAd sharedInstance].delegate = nil;
 }
 
 #pragma mark GADRewardBasedVideoAdDelegate
 
-- (void)rewardBasedVideoAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd
+- (void)rewardBasedVideoAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd
    didRewardUserWithReward:(GADAdReward *)reward {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoDidRewardUser" body:@{@"type": reward.type, @"amount": reward.amount}];
     }
 }
 
-- (void)rewardBasedVideoAdDidReceiveAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd {
+- (void)rewardBasedVideoAdDidReceiveAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoDidLoad" body:nil];
     }
-    _requestAdCallback(@[[NSNull null]]);
+    _requestAdResolve(nil);
 }
 
-- (void)rewardBasedVideoAdDidOpen:(GADRewardBasedVideoAd *)rewardBasedVideoAd {
+- (void)rewardBasedVideoAdDidOpen:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoDidOpen" body:nil];
     }
-    _showAdCallback(@[[NSNull null]]);
 }
 
-- (void)rewardBasedVideoAdDidStartPlaying:(GADRewardBasedVideoAd *)rewardBasedVideoAd {
+- (void)rewardBasedVideoAdDidStartPlaying:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoDidStartPlaying" body:nil];
     }
 }
 
-- (void)rewardBasedVideoAdDidClose:(GADRewardBasedVideoAd *)rewardBasedVideoAd {
+- (void)rewardBasedVideoAdDidClose:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoDidClose" body:nil];
     }
 }
 
-- (void)rewardBasedVideoAdWillLeaveApplication:(GADRewardBasedVideoAd *)rewardBasedVideoAd {
+- (void)rewardBasedVideoAdWillLeaveApplication:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {
     if (hasListeners) {
         [self sendEventWithName:@"rewardedVideoWillLeaveApplication" body:nil];
     }
 }
 
-- (void)rewardBasedVideoAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd
+- (void)rewardBasedVideoAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd
     didFailToLoadWithError:(NSError *)error {
     if (hasListeners) {
-        [self sendEventWithName:@"rewardedVideoDidFailToLoad" body:@{@"name": [error description]}];
+        NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);
+        [self sendEventWithName:@"rewardedVideoDidFailToLoad" body:jsError];
     }
-    _requestAdCallback(@[RCTJSErrorFromNSError(error)]);
+    _requestAdReject(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);
 }
 
 @end

Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ @implementation RNAdMobInterstitial {`
`10`	`10`	`GADInterstitial *_interstitial;`
`11`	`11`	`NSString *_adUnitID;`
`12`	`12`	`NSArray *_testDevices;`
`13`		`- RCTResponseSenderBlock _requestAdCallback;`
`14`		`- RCTResponseSenderBlock _showAdCallback;`
	`13`	`+ RCTPromiseResolveBlock _requestAdResolve;`
	`14`	`+ RCTPromiseRejectBlock _requestAdReject;`
`15`	`15`	`BOOL hasListeners;`
`16`	`16`	`}`
`17`	`17`
`@@ -44,32 +44,34 @@ - (dispatch_queue_t)methodQueue`
`44`	`44`	`_testDevices = testDevices;`
`45`	`45`	`}`
`46`	`46`
`47`		`-RCT_EXPORT_METHOD(requestAd:(RCTResponseSenderBlock)callback)`
	`47`	`+RCT_EXPORT_METHOD(requestAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)`
`48`	`48`	`{`
	`49`	`+ _requestAdResolve = nil;`
	`50`	`+ _requestAdReject = nil;`
	`51`	`+`
`49`	`52`	`if ([_interstitial hasBeenUsed] \|\| _interstitial == nil) {`
`50`		`- _requestAdCallback = callback;`
	`53`	`+ _requestAdResolve = resolve;`
	`54`	`+ _requestAdReject = reject;`
`51`	`55`
`52`	`56`	`_interstitial = [[GADInterstitial alloc] initWithAdUnitID:_adUnitID];`
`53`		`- if (hasListeners) {`
`54`		`- _interstitial.delegate = self;`
`55`		`- }`
	`57`	`+ _interstitial.delegate = self;`
`56`	`58`
`57`	`59`	`GADRequest *request = [GADRequest request];`
`58`	`60`	`request.testDevices = _testDevices;`
`59`	`61`	`[_interstitial loadRequest:request];`
`60`	`62`	`} else {`
`61`		`- callback(@[RCTMakeError(@"Ad is already loaded.", nil, nil)]);`
	`63`	`+ reject(@"E_AD_ALREADY_LOADED", @"Ad is already loaded.", nil);`
`62`	`64`	`}`
`63`	`65`	`}`
`64`	`66`
`65`		`-RCT_EXPORT_METHOD(showAd:(RCTResponseSenderBlock)callback)`
	`67`	`+RCT_EXPORT_METHOD(showAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)`
`66`	`68`	`{`
`67`	`69`	`if ([_interstitial isReady]) {`
`68`		`- _showAdCallback = callback;`
`69`	`70`	`[_interstitial presentFromRootViewController:[UIApplication sharedApplication].delegate.window.rootViewController];`
	`71`	`+ resolve(nil);`
`70`	`72`	`}`
`71`	`73`	`else {`
`72`		`- callback(@[RCTMakeError(@"Ad is not ready.", nil, nil)]);`
	`74`	`+ reject(@"E_AD_NOT_READY", @"Ad is not ready.", nil);`
`73`	`75`	`}`
`74`	`76`	`}`
`75`	`77`
`@@ -88,50 +90,43 @@ - (dispatch_queue_t)methodQueue`
`88`	`90`	`- (void)startObserving`
`89`	`91`	`{`
`90`	`92`	`hasListeners = YES;`
`91`		`- if (_interstitial) {`
`92`		`- _interstitial.delegate = self;`
`93`		`- }`
`94`	`93`	`}`
`95`	`94`
`96`	`95`	`- (void)stopObserving`
`97`	`96`	`{`
`98`	`97`	`hasListeners = NO;`
`99`		`- if (_interstitial) {`
`100`		`- _interstitial.delegate = nil;`
`101`		`- }`
`102`	`98`	`}`
`103`	`99`
`104`	`100`	`#pragma mark GADInterstitialDelegate`
`105`	`101`
`106`		`-- (void)interstitialDidReceiveAd:(GADInterstitial *)ad {`
	`102`	`+- (void)interstitialDidReceiveAd:(__unused GADInterstitial *)ad {`
`107`	`103`	`if (hasListeners) {`
`108`	`104`	`[self sendEventWithName:@"interstitialDidLoad" body:nil];`
`109`	`105`	`}`
`110`		`- _requestAdCallback(@[[NSNull null]]);`
	`106`	`+ _requestAdResolve(nil);`
`111`	`107`	`}`
`112`	`108`
`113`		`-- (void)interstitial:(GADInterstitial *)interstitial`
`114`		`-didFailToReceiveAdWithError:(GADRequestError *)error {`
	`109`	`+- (void)interstitial:(__unused GADInterstitial )interstitial didFailToReceiveAdWithError:(GADRequestError )error {`
`115`	`110`	`if (hasListeners) {`
`116`		`- [self sendEventWithName:@"interstitialDidFailToLoad" body:@{@"name": [error description]}];`
	`111`	`+ NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);`
	`112`	`+ [self sendEventWithName:@"interstitialDidFailToLoad" body:jsError];`
`117`	`113`	`}`
`118`		`- _requestAdCallback(@[[error description]]);`
	`114`	`+ _requestAdReject(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);`
`119`	`115`	`}`
`120`	`116`
`121`		`-- (void)interstitialWillPresentScreen:(GADInterstitial *)ad {`
	`117`	`+- (void)interstitialWillPresentScreen:(__unused GADInterstitial *)ad {`
`122`	`118`	`if (hasListeners){`
`123`	`119`	`[self sendEventWithName:@"interstitialDidOpen" body:nil];`
`124`	`120`	`}`
`125`		`- _showAdCallback(@[[NSNull null]]);`
`126`	`121`	`}`
`127`	`122`
`128`		`-- (void)interstitialDidDismissScreen:(GADInterstitial *)ad {`
	`123`	`+- (void)interstitialDidDismissScreen:(__unused GADInterstitial *)ad {`
`129`	`124`	`if (hasListeners) {`
`130`	`125`	`[self sendEventWithName:@"interstitialDidClose" body:nil];`
`131`	`126`	`}`
`132`	`127`	`}`
`133`	`128`
`134`		`-- (void)interstitialWillLeaveApplication:(GADInterstitial *)ad {`
	`129`	`+- (void)interstitialWillLeaveApplication:(__unused GADInterstitial *)ad {`
`135`	`130`	`if (hasListeners) {`
`136`	`131`	`[self sendEventWithName:@"interstitialWillLeaveApplication" body:nil];`
`137`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@`
`9`	`9`	`@implementation RNAdMobRewarded {`
`10`	`10`	`NSString *_adUnitID;`
`11`	`11`	`NSArray *_testDevices;`
`12`		`- RCTResponseSenderBlock _requestAdCallback;`
`13`		`- RCTResponseSenderBlock _showAdCallback;`
	`12`	`+ RCTPromiseResolveBlock _requestAdResolve;`
	`13`	`+ RCTPromiseRejectBlock _requestAdReject;`
`14`	`14`	`BOOL hasListeners;`
`15`	`15`	`}`
`16`	`16`
`@@ -45,26 +45,28 @@ - (dispatch_queue_t)methodQueue`
`45`	`45`	`_testDevices = testDevices;`
`46`	`46`	`}`
`47`	`47`
`48`		`-RCT_EXPORT_METHOD(requestAd:(RCTResponseSenderBlock)callback)`
	`48`	`+RCT_EXPORT_METHOD(requestAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)`
`49`	`49`	`{`
`50`		`- _requestAdCallback = callback;`
	`50`	`+ _requestAdResolve = resolve;`
	`51`	`+ _requestAdReject = reject;`
	`52`	`+`
`51`	`53`	`[GADRewardBasedVideoAd sharedInstance].delegate = self;`
`52`	`54`	`GADRequest *request = [GADRequest request];`
`53`	`55`	`request.testDevices = _testDevices;`
`54`	`56`	`[[GADRewardBasedVideoAd sharedInstance] loadRequest:request`
`55`	`57`	`withAdUnitID:_adUnitID];`
`56`	`58`	`}`
`57`	`59`
`58`		`-RCT_EXPORT_METHOD(showAd:(RCTResponseSenderBlock)callback)`
	`60`	`+RCT_EXPORT_METHOD(showAd:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)`
`59`	`61`	`{`
`60`	`62`	`if ([[GADRewardBasedVideoAd sharedInstance] isReady]) {`
`61`		`- _showAdCallback = callback;`
`62`	`63`	`UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];`
`63`	`64`	`UIViewController *rootViewController = [keyWindow rootViewController];`
`64`	`65`	`[[GADRewardBasedVideoAd sharedInstance] presentFromRootViewController:rootViewController];`
	`66`	`+ resolve(nil);`
`65`	`67`	`}`
`66`	`68`	`else {`
`67`		`- callback(@[RCTMakeError(@"Ad is not ready", nil, nil)]);`
	`69`	`+ reject(@"E_AD_NOT_READY", @"Ad is not ready.", nil);`
`68`	`70`	`}`
`69`	`71`	`}`
`70`	`72`
`@@ -83,62 +85,60 @@ - (dispatch_queue_t)methodQueue`
`83`	`85`	`- (void)startObserving`
`84`	`86`	`{`
`85`	`87`	`hasListeners = YES;`
`86`		`- [GADRewardBasedVideoAd sharedInstance].delegate = self;`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`- (void)stopObserving`
`90`	`91`	`{`
`91`	`92`	`hasListeners = NO;`
`92`		`- [GADRewardBasedVideoAd sharedInstance].delegate = nil;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`#pragma mark GADRewardBasedVideoAdDelegate`
`96`	`96`
`97`		`-- (void)rewardBasedVideoAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd`
	`97`	`+- (void)rewardBasedVideoAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd`
`98`	`98`	`didRewardUserWithReward:(GADAdReward *)reward {`
`99`	`99`	`if (hasListeners) {`
`100`	`100`	`[self sendEventWithName:@"rewardedVideoDidRewardUser" body:@{@"type": reward.type, @"amount": reward.amount}];`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`		`-- (void)rewardBasedVideoAdDidReceiveAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd {`
	`104`	`+- (void)rewardBasedVideoAdDidReceiveAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {`
`105`	`105`	`if (hasListeners) {`
`106`	`106`	`[self sendEventWithName:@"rewardedVideoDidLoad" body:nil];`
`107`	`107`	`}`
`108`		`- _requestAdCallback(@[[NSNull null]]);`
	`108`	`+ _requestAdResolve(nil);`
`109`	`109`	`}`
`110`	`110`
`111`		`-- (void)rewardBasedVideoAdDidOpen:(GADRewardBasedVideoAd *)rewardBasedVideoAd {`
	`111`	`+- (void)rewardBasedVideoAdDidOpen:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {`
`112`	`112`	`if (hasListeners) {`
`113`	`113`	`[self sendEventWithName:@"rewardedVideoDidOpen" body:nil];`
`114`	`114`	`}`
`115`		`- _showAdCallback(@[[NSNull null]]);`
`116`	`115`	`}`
`117`	`116`
`118`		`-- (void)rewardBasedVideoAdDidStartPlaying:(GADRewardBasedVideoAd *)rewardBasedVideoAd {`
	`117`	`+- (void)rewardBasedVideoAdDidStartPlaying:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {`
`119`	`118`	`if (hasListeners) {`
`120`	`119`	`[self sendEventWithName:@"rewardedVideoDidStartPlaying" body:nil];`
`121`	`120`	`}`
`122`	`121`	`}`
`123`	`122`
`124`		`-- (void)rewardBasedVideoAdDidClose:(GADRewardBasedVideoAd *)rewardBasedVideoAd {`
	`123`	`+- (void)rewardBasedVideoAdDidClose:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {`
`125`	`124`	`if (hasListeners) {`
`126`	`125`	`[self sendEventWithName:@"rewardedVideoDidClose" body:nil];`
`127`	`126`	`}`
`128`	`127`	`}`
`129`	`128`
`130`		`-- (void)rewardBasedVideoAdWillLeaveApplication:(GADRewardBasedVideoAd *)rewardBasedVideoAd {`
	`129`	`+- (void)rewardBasedVideoAdWillLeaveApplication:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd {`
`131`	`130`	`if (hasListeners) {`
`132`	`131`	`[self sendEventWithName:@"rewardedVideoWillLeaveApplication" body:nil];`
`133`	`132`	`}`
`134`	`133`	`}`
`135`	`134`
`136`		`-- (void)rewardBasedVideoAd:(GADRewardBasedVideoAd *)rewardBasedVideoAd`
	`135`	`+- (void)rewardBasedVideoAd:(__unused GADRewardBasedVideoAd *)rewardBasedVideoAd`
`137`	`136`	`didFailToLoadWithError:(NSError *)error {`
`138`	`137`	`if (hasListeners) {`
`139`		`- [self sendEventWithName:@"rewardedVideoDidFailToLoad" body:@{@"name": [error description]}];`
	`138`	`+ NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);`
	`139`	`+ [self sendEventWithName:@"rewardedVideoDidFailToLoad" body:jsError];`
`140`	`140`	`}`
`141`		`- _requestAdCallback(@[RCTJSErrorFromNSError(error)]);`
	`141`	`+ _requestAdReject(@"E_AD_REQUEST_FAILED", error.localizedDescription, error);`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`@end`