react-native-firebase-compiled/es5/modules/admob/Interstitial.js

A well tested, feature rich Firebase implementation for React Native, supporting iOS & Android. Individual module support for Admob, Analytics, Auth, Crash Reporting, Cloud Firestore, Database, Dynamic Links, Functions, Messaging (FCM), Remote Config, Sto

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _reactNative = require("react-native");

var _ = require(".");

var _AdRequest = _interopRequireDefault(require("./AdRequest"));

var _events = require("../../utils/events");

var _native = require("../../utils/native");

var _utils = require("../../utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

let subscriptions = [];

class Interstitial {
  constructor(admob, adUnit) {
    _defineProperty(this, "_admob", void 0);

    _defineProperty(this, "_onInterstitialEvent", event => {
      const eventType = `interstitial:${this.adUnit}:${event.type}`;
      let emitData = Object.assign({}, event);

      switch (event.type) {
        case 'onAdLoaded':
          this.loaded = true;
          break;

        case 'onAdFailedToLoad':
          emitData = (0, _utils.nativeToJSError)(event.payload.code, event.payload.message);
          emitData.type = event.type;
          break;

        default:
      }

      _events.SharedEventEmitter.emit(eventType, emitData);

      _events.SharedEventEmitter.emit(`interstitial:${this.adUnit}:*`, emitData);
    });

    // Interstitials on iOS require a new instance each time
    if (_reactNative.Platform.OS === 'ios') {
      (0, _native.getNativeModule)(admob).clearInterstitial(adUnit);
    }

    for (let i = 0, len = subscriptions.length; i < len; i++) {
      subscriptions[i].remove();
    }

    subscriptions = [];
    this._admob = admob;
    this.adUnit = adUnit;
    this.loaded = false;

    _events.SharedEventEmitter.removeAllListeners(`interstitial_${adUnit}`);

    _events.SharedEventEmitter.addListener(`interstitial_${adUnit}`, this._onInterstitialEvent);
  }
  /**
   * Handle a JS emit event
   * @param event
   * @private
   */


  /**
   * Load an ad with an instance of AdRequest
   * @param request
   * @returns {*}
   */
  loadAd(request) {
    let adRequest = request;

    if (!adRequest || !Object.keys(adRequest)) {
      adRequest = new _AdRequest.default().addTestDevice().build();
    }

    return (0, _native.getNativeModule)(this._admob).interstitialLoadAd(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) {
      (0, _native.getNativeModule)(this._admob).interstitialShowAd(this.adUnit);
    }
  }
  /**
   * Listen to an Ad event
   * @param eventType
   * @param listenerCb
   * @returns {null}
   */


  on(eventType, listenerCb) {
    if (!_.statics.EventTypes[eventType]) {
      console.warn(`Invalid event type provided, must be one of: ${Object.keys(_.statics.EventTypes).join(', ')}`);
      return null;
    }

    const sub = _events.SharedEventEmitter.addListener(`interstitial:${this.adUnit}:${eventType}`, listenerCb);

    subscriptions.push(sub);
    return sub;
  }

}

exports.default = Interstitial;