all files / firebase/modules/admob/ RewardedVideo.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
 
 
 
 
 
 
2×
 
 
 
 
 
2×
 
 
2×
 
2×
2×
2×
2×
2×
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import { statics } from './';
import AdRequest from './AdRequest';
import { SharedEventEmitter } from '../../utils/events';
import { getNativeModule } from '../../utils/native';
import { nativeToJSError } from '../../utils';
import type AdMob from './';
 
let subscriptions = [];
 
export default class RewardedVideo {
  _admob: AdMob;
 
  constructor(admob: AdMob, adUnit: string) {
    for (let i = 0, len = subscriptions.length; i < len; i++) {
      subscriptions[i].remove();
    }
    subscriptions = [];
 
    this._admob = admob;
    this.adUnit = adUnit;
    this.loaded = false;
    SharedEventEmitter.removeAllListeners(`rewarded_video_${adUnit}`);
    SharedEventEmitter.addListener(
      `rewarded_video_${adUnit}`,
      this._onRewardedVideoEvent
    );
  }
 
  /**
   * Handle a JS emit event
   * @param event
   * @private
   */
  _onRewardedVideoEvent = event => {
    const eventType = `rewarded_video:${this.adUnit}:${event.type}`;
 
    let emitData = Object.assign({}, event);
 
    switch (event.type) {
      case 'onAdLoaded':
        this.loaded = true;
        break;
      case 'onAdFailedToLoad':
        emitData = nativeToJSError(event.payload.code, event.payload.message);
        emitData.type = event.type;
        break;
      default:
    }
 
    SharedEventEmitter.emit(eventType, emitData);
    SharedEventEmitter.emit(`rewarded_video:${this.adUnit}:*`, emitData);
  };
 
  /**
   * Load an ad with an instance of AdRequest
   * @param request
   * @returns {*}
   */
  loadAd(request?: AdRequest) {
    let adRequest = request;
 
    if (!adRequest || !Object.keys(adRequest)) {
      adRequest = new AdRequest().addTestDevice().build();
    }
 
    return getNativeModule(this._admob).rewardedVideoLoadAd(
      this.adUnit,
      adRequest
    );
  }
 
  /**
   * Return a local instance of isLoaded
   * @returns {boolean}
   */
  isLoaded() {
    return this.loaded;
  }
 
  /**
   * Show the advert - will only show if loaded
   * @returns {*}
   */
  show() {
    if (this.loaded) {
      getNativeModule(this._admob).rewardedVideoShowAd(this.adUnit);
    }
  }
 
  /**
   * Listen to an Ad event
   * @param eventType
   * @param listenerCb
   * @returns {null}
   */
  on(eventType, listenerCb) {
    const types = {
      ...statics.EventTypes,
      ...statics.RewardedVideoEventTypes,
    };
 
    if (!types[eventType]) {
      console.warn(
        `Invalid event type provided, must be one of: ${Object.keys(types).join(
          ', '
        )}`
      );
      return null;
    }
 
    const sub = SharedEventEmitter.addListener(
      `rewarded_video:${this.adUnit}:${eventType}`,
      listenerCb
    );
    subscriptions.push(sub);
    return sub;
  }
}