https://www.cadena3.com/js/videojs.ima.js

391 The player's width.
392 */
393PlayerWrapper.prototype.getPlayerWidth = function () {
394  let width = (getComputedStyle(this.vjsPlayer.el()) || {}).width;
395
396  if (!width || parseFloat(width) === 0) {
397    width = (this.vjsPlayer.el().getBoundingClientRect() || {}).width;
398  }
399
400  return parseFloat(width) || this.vjsPlayer.width();
401};
402
403/**
404 * Get the player height.
405 *
406 * @return {number} The player's height.
407 */
408PlayerWrapper.prototype.getPlayerHeight = function () {
409  let height = (getComputedStyle(this.vjsPlayer.el()) || {}).height;
410
411  if (!height || parseFloat(height) === 0) {
412    height = (this.vjsPlayer.el().getBoundingClientRect() || {}).height;
413  }
414
415  return parseFloat(height) || this.vjsPlayer.height();
416};
417
418/**
419 * @return {Object} The vjs player's options object.
420 */
421PlayerWrapper.prototype.getPlayerOptions = function () {
422  return this.vjsPlayer.options_;
423};
424
425/**
426 * Returns the instance of the player id.
427 * @return {string} The player id.
428 */
429PlayerWrapper.prototype.getPlayerId = function () {
430  return this.vjsPlayer.id();
431};
432
433/**
434 * Toggle fullscreen state.
435 */
436PlayerWrapper.prototype.toggleFullscreen = function () {
437  if (this.vjsPlayer.isFullscreen()) {
438    this.vjsPlayer.exitFullscreen();
439  } else {
440    this.vjsPlayer.requestFullscreen();
441  }
442};
443
444/**
445 * Returns the content playhead tracker.
446 *
447 * @return {Object} The content playhead tracker.
448 */
449PlayerWrapper.prototype.getContentPlayheadTracker = function () {
450  return this.contentPlayheadTracker;
451};
452
453/**
454 * Handles ad errors.
455 *
456 * @param {Object} adErrorEvent The ad error event thrown by the IMA SDK.
457 */
458PlayerWrapper.prototype.onAdError = function (adErrorEvent) {
459  this.vjsControls.show();
460  const errorMessage = adErrorEvent.getError !== undefined ? adErrorEvent.getError() : adErrorEvent.stack;
461  this.vjsPlayer.trigger({ type: 'adserror', data: {
462      AdError: errorMessage,
463      AdErrorEvent: adErrorEvent
464    } });
465};
466
467/**
468 * Handles ad log messages.
469 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the IMA SDK.
470 */
471PlayerWrapper.prototype.onAdLog = function (adEvent) {
472  const adData = adEvent.getAdData();
473  const errorMessage = adData['adError'] !== undefined ? adData['adError'].getMessage() : undefined;
474  this.vjsPlayer.trigger({ type: 'adslog', data: {
475      AdError: errorMessage,
476      AdEvent: adEvent
477    } });
478};
479
480/**
481 * Handles ad break starting.
482 */
483PlayerWrapper.prototype.onAdBreakStart = function () {
484  this.contentSource = this.vjsPlayer.currentSrc();
485  this.contentSourceType = this.vjsPlayer.currentType();
486  this.vjsPlayer.off('contentended', this.boundContentEndedListener);
487  this.vjsPlayer.ads.startLinearAdMode();
488  this.vjsControls.hide();
489  this.vjsPlayer.pause();
490};
491
492/**
493 * Handles ad break ending.
494 */
495PlayerWrapper.prototype.onAdBreakEnd = function () {
496  this.vjsPlayer.on('contentended', this.boundContentEndedListener);
497  if (this.vjsPlayer.ads.inAdBreak()) {
498    this.vjsPlayer.ads.endLinearAdMode();
499  }
500  this.vjsControls.show();
501};
502
503/**
504 * Handles an individual ad start.
505 */
506PlayerWrapper.prototype.onAdStart = function () {
507  this.vjsPlayer.trigger('ads-ad-started');
508};
509
510/**
511 * Handles when all ads have finished playing.
512 */
513PlayerWrapper.prototype.onAllAdsCompleted = function () {
514  if (this.contentComplete == true) {
515    // The null check on this.contentSource was added to fix
516    // an error when the post-roll was an empty VAST tag.
517    if (this.contentSource && this.vjsPlayer.currentSrc() != this.contentSource) {
518      this.vjsPlayer.src({
519        src: this.contentSource,
520        type: this.contentSourceType
521      });
522    }
523    this.controller.onContentAndAdsCompleted();
524  }
525};
526
527/**
528 * Triggers adsready for contrib-ads.
529 */
530PlayerWrapper.prototype.onAdsReady = function () {
531  this.vjsPlayer.trigger('adsready');
532};
533
534/**
535 * Changes the player source.
536 * @param {?string} contentSrc The URI for the content to be played. Leave
537 *     blank to use the existing content.
538 */
539PlayerWrapper.prototype.changeSource = function (contentSrc) {
540  // Only try to pause the player when initialised with a source already
541  if (this.vjsPlayer.currentSrc()) {
542    this.vjsPlayer.currentTime(0);
543    this.vjsPlayer.pause();
544  }
545  if (contentSrc) {
546    this.vjsPlayer.src(contentSrc);
547  }
548  this.vjsPlayer.one('loadedmetadata', this.seekContentToZero.bind(this));
549};
550
551/**
552 * Seeks content to 00:00:00. This is used as an event handler for the
553 * loadedmetadata event, since seeking is not possible until that event has
554 * fired.
555 */
556PlayerWrapper.prototype.seekContentToZero = function () {
557  this.vjsPlayer.currentTime(0);
558};
559
560/**
561 * Triggers an event on the VJS player
562 * @param  {string} name The event name.
563 * @param  {Object} data The event data.
564 */
565PlayerWrapper.prototype.triggerPlayerEvent = function (name, data) {
566  this.vjsPlayer.trigger(name, data);
567};
568
569/**
570 * Listener JSDoc for ESLint. This listener can be passed to
571 * addContentEndedListener.
572 * @callback listener
573 */
574
575/**
576 * Adds a listener for the 'contentended' event of the video player. This should
577 * be used instead of setting an 'contentended' listener directly to ensure that
578 * the ima can do proper cleanup of the SDK before other event listeners are
579 * called.
580 * @param {listener} listener The listener to be called when content
581 *     completes.
582 */
583PlayerWrapper.prototype.addContentEndedListener = function (listener) {
584  this.contentEndedListeners.push(listener);
585};
586
587/**
588 * Reset the player.
589 */
590PlayerWrapper.prototype.reset = function () {
591  // Attempts to remove the contentEndedListener before adding it.
592  // This is to prevent an error where an erroring video caused multiple
593  // contentEndedListeners to be added.
594  this.vjsPlayer.off('contentended', this.boundContentEndedListener);
595
596  this.vjsPlayer.on('contentended', this.boundContentEndedListener);
597  this.vjsControls.show();
598  if (this.vjsPlayer.ads.inAdBreak()) {
599    this.vjsPlayer.ads.endLinearAdMode();
600  }
601  // Reset the content time we give the SDK. Fixes an issue where requesting
602  // VMAP followed by VMAP would play the second mid-rolls as pre-rolls if
603  // the first playthrough of the video passed the second response's
604  // mid-roll time.
605  this.contentPlayheadTracker.currentTime = 0;
606  this.contentComplete = false;
607};
608
609/**
610 * Copyright 2017 Google Inc.
611 *
612 * Licensed under the Apache License, Version 2.0 (the "License");
613 * you may not use this file except in compliance with the License.
614 * You may obtain a copy of the License at
615 *
616 *     http://www.apache.org/licenses/LICENSE-2.0
617 *
618 * Unless required by applicable law or agreed to in writing, software
619 * distributed under the License is distributed on an "AS IS" BASIS,
620 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
621 * See the License for the specific language governing permissions and
622 * limitations under the License.
623 *
624 * IMA SDK integration plugin for Video.js. For more information see
625 * https://www.github.com/googleads/videojs-ima
626 */
627
628/**
629 * Ad UI implementation.
630 *
631 * @param {Controller} controller Plugin controller.
632 * @constructor
633 * @struct
634 * @final
635 */
636const AdUi = function (controller) {
637  /**
638   * Plugin controller.
639   */
640  this.controller = controller;
641
642  /**
643   * Div used as an ad container.
644   */
645  this.adContainerDiv = document.createElement('div');
646
647  /**
648   * Div used to display ad controls.
649   */
650  this.controlsDiv = document.createElement('div');
651
652  /**
653   * Div used to display ad countdown timer.
654   */
655  this.countdownDiv = document.createElement('div');
656
657  /**
658   * Div used to display add seek bar.
659   */
660  this.seekBarDiv = document.createElement('div');
661
662  /**
663   * Div used to display ad progress (in seek bar).
664   */
665  this.progressDiv = document.createElement('div');
666
667  /**
668   * Div used to display ad play/pause button.
669   */
670  this.playPauseDiv = document.createElement('div');
671
672  /**
673   * Div used to display ad mute button.
674   */
675  this.muteDiv = document.createElement('div');
676
677  /**
678   * Div used by the volume slider.
679   */
680  this.sliderDiv = document.createElement('div');
681
682  /**
683   * Volume slider level visuals
684   */
685  this.sliderLevelDiv = document.createElement('div');
686
687  /**
688   * Div used to display ad fullscreen button.
689   */
690  this.fullscreenDiv = document.createElement('div');
691
692  /**
693   * Bound event handler for onMouseUp.
694   */
695  this.boundOnMouseUp = this.onMouseUp.bind(this);
696
697  /**
698   * Bound event handler for onMouseMove.
699   */
700  this.boundOnMouseMove = this.onMouseMove.bind(this);
701
702  /**
703   * Stores data for the ad playhead tracker.
704   */
705  this.adPlayheadTracker = {
706    'currentTime': 0,
707    'duration': 0,
708    'isPod': false,
709    'adPosition': 0,
710    'totalAds': 0
711  };
712
713  /**
714   * Used to prefix videojs ima controls.
715   */
716  this.controlPrefix = this.controller.getPlayerId() + '_';
717
718  /**
719   * Boolean flag to show or hide the ad countdown timer.
720   */
721  this.showCountdown = true;
722  if (this.controller.getSettings().showCountdown === false) {
723    this.showCountdown = false;
724  }
725
726  /**
727   * Boolean flag if the current ad is nonlinear.
728   */
729  this.isAdNonlinear = false;
730
731  this.createAdContainer();
732};
733
734/**
735 * Creates the ad container.
736 */
737AdUi.prototype.createAdContainer = function () {
738  this.assignControlAttributes(this.adContainerDiv, 'ima-ad-container');
739  this.adContainerDiv.style.position = 'absolute';
740  this.adContainerDiv.style.zIndex = 1111;
741  this.adContainerDiv.addEventListener('mouseenter', this.showAdControls.bind(this), false);
742  this.adContainerDiv.addEventListener('mouseleave', this.hideAdControls.bind(this), false);
743  this.adContainerDiv.addEventListener('click', this.onAdContainerClick.bind(this), false);
744  this.createControls();
745  this.controller.injectAdContainerDiv(this.adContainerDiv);
746};
747
748/**
749 * Create the controls.
750 */
751AdUi.prototype.createControls = function () {
752  this.assignControlAttributes(this.controlsDiv, 'ima-controls-div');
753  this.controlsDiv.style.width = '100%';
754
755  if (!this.controller.getIsMobile()) {
756    this.assignControlAttributes(this.countdownDiv, 'ima-countdown-div');
757    this.countdownDiv.innerHTML = this.controller.getSettings().adLabel;
758    this.countdownDiv.style.display = this.showCountdown ? 'block' : 'none';
759  } else {
760    this.countdownDiv.style.display = 'none';
761  }
762
763  this.assignControlAttributes(this.seekBarDiv, 'ima-seek-bar-div');
764  this.seekBarDiv.style.width = '100%';
765
766  this.assignControlAttributes(this.progressDiv, 'ima-progress-div');
767
768  this.assignControlAttributes(this.playPauseDiv, 'ima-play-pause-div');
769  this.addClass(this.playPauseDiv, 'ima-playing');
770  this.playPauseDiv.addEventListener('click', this.onAdPlayPauseClick.bind(this), false);
771
772  this.assignControlAttributes(this.muteDiv, 'ima-mute-div');
773  this.addClass(this.muteDiv, 'ima-non-muted');
774  this.muteDiv.addEventListener('click', this.onAdMuteClick.bind(this), false);
775
776  this.assignControlAttributes(this.sliderDiv, 'ima-slider-div');
777  this.sliderDiv.addEventListener('mousedown', this.onAdVolumeSliderMouseDown.bind(this), false);
778
779  // Hide volume slider controls on iOS as they aren't supported.
780  if (this.controller.getIsIos()) {
781    this.sliderDiv.style.display = 'none';
782  }
783
784  this.assignControlAttributes(this.sliderLevelDiv, 'ima-slider-level-div');
785
786  this.assignControlAttributes(this.fullscreenDiv, 'ima-fullscreen-div');
787  this.addClass(this.fullscreenDiv, 'ima-non-fullscreen');
788  this.fullscreenDiv.addEventListener('click', this.onAdFullscreenClick.bind(this), false);
789
790  this.adContainerDiv.appendChild(this.controlsDiv);
791  this.controlsDiv.appendChild(this.countdownDiv);
792  this.controlsDiv.appendChild(this.seekBarDiv);
793  this.controlsDiv.appendChild(this.playPauseDiv);
794  this.controlsDiv.appendChild(this.muteDiv);
795  this.controlsDiv.appendChild(this.sliderDiv);
796  this.controlsDiv.appendChild(this.fullscreenDiv);
797  this.seekBarDiv.appendChild(this.progressDiv);
798  this.sliderDiv.appendChild(this.sliderLevelDiv);
799};
800
801/**
802 * Listener for clicks on the play/pause button during ad playback.
803 */
804AdUi.prototype.onAdPlayPauseClick = function () {
805  this.controller.onAdPlayPauseClick();
806};
807
808/**
809 * Listener for clicks on the play/pause button during ad playback.
810 */
811AdUi.prototype.onAdMuteClick = function () {
812  this.controller.onAdMuteClick();
813};
814
815/**
816 * Listener for clicks on the fullscreen button during ad playback.
817 */
818AdUi.prototype.onAdFullscreenClick = function () {
819  this.controller.toggleFullscreen();
820};
821
822/**
823 * Show pause and hide play button
824 */
825AdUi.prototype.onAdsPaused = function () {
826  this.controller.sdkImpl.adPlaying = false;

1022};
1023
1024/**
1025 * Handles when a non-linear ad starts.
1026 */
1027AdUi.prototype.onNonLinearAdLoad = function () {
1028  // For non-linear ads that show after a linear ad. For linear ads, we show the
1029  // ad container in onAdBreakStart to prevent blinking in pods.
1030  this.adContainerDiv.style.display = 'block';
1031  // Bump container when controls are shown
1032  this.addClass(this.adContainerDiv, 'bumpable-ima-ad-container');
1033  this.isAdNonlinear = true;
1034};
1035
1036AdUi.prototype.onPlayerEnterFullscreen = function () {
1037  this.addClass(this.fullscreenDiv, 'ima-fullscreen');
1038  this.removeClass(this.fullscreenDiv, 'ima-non-fullscreen');
1039};
1040
1041AdUi.prototype.onPlayerExitFullscreen = function () {
1042  this.addClass(this.fullscreenDiv, 'ima-non-fullscreen');
1043  this.removeClass(this.fullscreenDiv, 'ima-fullscreen');
1044};
1045
1046/**
1047 * Called when the player volume changes.
1048 *
1049 * @param {number} volume The new player volume.
1050 */
1051AdUi.prototype.onPlayerVolumeChanged = function (volume) {
1052  if (volume == 0) {
1053    this.addClass(this.muteDiv, 'ima-muted');
1054    this.removeClass(this.muteDiv, 'ima-non-muted');
1055    this.sliderLevelDiv.style.width = '0%';
1056  } else {
1057    this.addClass(this.muteDiv, 'ima-non-muted');
1058    this.removeClass(this.muteDiv, 'ima-muted');
1059    this.sliderLevelDiv.style.width = volume * 100 + '%';
1060  }
1061};
1062
1063/**
1064 * Shows ad controls on mouseover.
1065 */
1066AdUi.prototype.showAdControls = function () {
1067  const { disableAdControls } = this.controller.getSettings();
1068  if (!disableAdControls) {
1069    this.addClass(this.controlsDiv, 'ima-controls-div-showing');
1070  }
1071};
1072
1073/**
1074 * Hide the ad controls.
1075 */
1076AdUi.prototype.hideAdControls = function () {
1077  this.removeClass(this.controlsDiv, 'ima-controls-div-showing');
1078};
1079
1080/**
1081 * Assigns the unique id and class names to the given element as well as the
1082 * style class.
1083 * @param {HTMLElement} element Element that needs the controlName assigned.
1084 * @param {string} controlName Control name to assign.
1085 */
1086AdUi.prototype.assignControlAttributes = function (element, controlName) {
1087  element.id = this.controlPrefix + controlName;
1088  element.className = this.controlPrefix + controlName + ' ' + controlName;
1089};
1090
1091/**
1092 * Returns a regular expression to test a string for the given className.
1093 *
1094 * @param {string} className The name of the class.
1095 * @return {RegExp} The regular expression used to test for that class.
1096 */
1097AdUi.prototype.getClassRegexp = function (className) {
1098  // Matches on
1099  // (beginning of string OR NOT word char)
1100  // classname
1101  // (negative lookahead word char OR end of string)
1102  return new RegExp('(^|[^A-Za-z-])' + className + '((?![A-Za-z-])|$)', 'gi');
1103};
1104
1105/**
1106 * Returns whether or not the provided element has the provied class in its
1107 * className.
1108 * @param {HTMLElement} element Element to tes.t
1109 * @param {string} className Class to look for.
1110 * @return {boolean} True if element has className in class list. False
1111 *     otherwise.
1112 */
1113AdUi.prototype.elementHasClass = function (element, className) {
1114  const classRegexp = this.getClassRegexp(className);
1115  return classRegexp.test(element.className);
1116};
1117
1118/**
1119 * Adds a class to the given element if it doesn't already have the class
1120 * @param {HTMLElement} element Element to which the class will be added.
1121 * @param {string} classToAdd Class to add.
1122 */
1123AdUi.prototype.addClass = function (element, classToAdd) {
1124  element.className = element.className.trim() + ' ' + classToAdd;
1125};
1126
1127/**
1128 * Removes a class from the given element if it has the given class
1129 *
1130 * @param {HTMLElement} element Element from which the class will be removed.
1131 * @param {string} classToRemove Class to remove.
1132 */
1133AdUi.prototype.removeClass = function (element, classToRemove) {
1134  const classRegexp = this.getClassRegexp(classToRemove);
1135  element.className = element.className.trim().replace(classRegexp, '');
1136};
1137
1138/**
1139 * @return {HTMLElement} The div for the ad container.
1140 */
1141AdUi.prototype.getAdContainerDiv = function () {
1142  return this.adContainerDiv;
1143};
1144
1145/**
1146 * Changes the flag to show or hide the ad countdown timer.
1147 *
1148 * @param {boolean} showCountdownIn Show or hide the countdown timer.
1149 */
1150AdUi.prototype.setShowCountdown = function (showCountdownIn) {
1151  this.showCountdown = showCountdownIn;
1152  this.countdownDiv.style.display = this.showCountdown ? 'block' : 'none';
1153};
1154
1155var name = "videojs-ima";
1156var version = "2.0.1";
1157var license = "Apache-2.0";
1158var main = "./dist/videojs.ima.js";
1159var module$1 = "./dist/videojs.ima.es.js";
1160var author = { "name": "Google Inc." };
1161var engines = { "node": ">=0.8.0" };
1162var scripts = { "contBuild": "watch 'npm run rollup:max' src", "predevServer": "echo \"Starting up server on localhost:8000.\"", "devServer": "npm-run-all -p testServer contBuild", "lint": "eslint \"src/**/*.js\"", "rollup": "npm-run-all rollup:*", "rollup:max": "rollup -c configs/rollup.config.js", "rollup:es": "rollup -c configs/rollup.config.es.js", "rollup:min": "rollup -c configs/rollup.config.min.js", "pretest": "npm run rollup", "start": "npm run devServer", "test": "npm-run-all test:*", "test:vjs6": "npm install video.js@6 --no-save && npm-run-all -p -r testServer webdriver", "test:vjs7": "npm install video.js@7 --no-save && npm-run-all -p -r testServer webdriver", "testServer": "http-server --cors -p 8000 --silent", "preversion": "node scripts/preversion.js && npm run lint && npm test", "version": "node scripts/version.js", "postversion": "node scripts/postversion.js", "webdriver": "mocha test/webdriver/*.js --no-timeouts" };
1163var repository = { "type": "git", "url": "https://github.com/googleads/videojs-ima" };
1164var files = ["CHANGELOG.md", "LICENSE", "README.md", "dist/", "src/"];

1312  }
1313
1314  // Set SDK settings from plugin settings.
1315  if (this.controller.getSettings().locale) {
1316    /* eslint no-undef: 'error' */
1317    /* global google */
1318    google.ima.settings.setLocale(this.controller.getSettings().locale);
1319  }
1320  if (this.controller.getSettings().disableFlashAds) {
1321    google.ima.settings.setDisableFlashAds(this.controller.getSettings().disableFlashAds);
1322  }
1323  if (this.controller.getSettings().disableCustomPlaybackForIOS10Plus) {
1324    google.ima.settings.setDisableCustomPlaybackForIOS10Plus(this.controller.getSettings().disableCustomPlaybackForIOS10Plus);
1325  }
1326
1327  if (this.controller.getSettings().ppid) {
1328    google.ima.settings.setPpid(this.controller.getSettings().ppid);
1329  }
1330
1331  if (this.controller.getSettings().featureFlags) {
1332    google.ima.settings.setFeatureFlags(this.controller.getSettings().featureFlags);
1333  }
1334};
1335
1336/**
1337 * Creates and initializes the IMA SDK objects.
1338 */
1339SdkImpl.prototype.initAdObjects = function () {
1340  this.adDisplayContainer = new google.ima.AdDisplayContainer(this.controller.getAdContainerDiv(), this.controller.getContentPlayer());
1341
1342  this.adsLoader = new google.ima.AdsLoader(this.adDisplayContainer);
1343
1344  this.adsLoader.getSettings().setVpaidMode(google.ima.ImaSdkSettings.VpaidMode.ENABLED);
1345  if (this.controller.getSettings().vpaidAllowed == false) {
1346    this.adsLoader.getSettings().setVpaidMode(google.ima.ImaSdkSettings.VpaidMode.DISABLED);
1347  }
1348  if (this.controller.getSettings().vpaidMode !== undefined) {
1349    this.adsLoader.getSettings().setVpaidMode(this.controller.getSettings().vpaidMode);
1350  }
1351
1352  if (this.controller.getSettings().locale) {
1353    this.adsLoader.getSettings().setLocale(this.controller.getSettings().locale);
1354  }
1355
1356  if (this.controller.getSettings().numRedirects) {
1357    this.adsLoader.getSettings().setNumRedirects(this.controller.getSettings().numRedirects);
1358  }
1359
1360  if (this.controller.getSettings().sessionId) {
1361    this.adsLoader.getSettings().setSessionId(this.controller.getSettings().sessionId);
1362  }
1363
1364  this.adsLoader.getSettings().setPlayerType('videojs-ima');
1365  this.adsLoader.getSettings().setPlayerVersion(pkg.version);
1366  this.adsLoader.getSettings().setAutoPlayAdBreaks(this.autoPlayAdBreaks);
1367
1368  this.adsLoader.addEventListener(google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED, this.onAdsManagerLoaded.bind(this), false);
1369  this.adsLoader.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, this.onAdsLoaderError.bind(this), false);
1370
1371  this.controller.playerWrapper.vjsPlayer.trigger({
1372    type: 'ads-loader',
1373    adsLoader: this.adsLoader
1374  });
1375};
1376
1377/**
1378 * Creates the AdsRequest and request ads through the AdsLoader.
1379 */
1380SdkImpl.prototype.requestAds = function () {
1381  const adsRequest = new google.ima.AdsRequest();
1382  if (this.controller.getSettings().adTagUrl) {
1383    adsRequest.adTagUrl = this.controller.getSettings().adTagUrl;
1384  } else {
1385    adsRequest.adsResponse = this.controller.getSettings().adsResponse;
1386  }
1387  if (this.controller.getSettings().forceNonLinearFullSlot) {
1388    adsRequest.forceNonLinearFullSlot = true;
1389  }
1390
1391  if (this.controller.getSettings().vastLoadTimeout) {
1392    adsRequest.vastLoadTimeout = this.controller.getSettings().vastLoadTimeout;
1393  }
1394
1395  if (this.controller.getSettings().omidMode) {
1396    adsRequest.omidAccessModeRules = {};
1397    const omidValues = this.controller.getSettings().omidMode;
1398
1399    if (omidValues.FULL) {
1400      adsRequest.omidAccessModeRules[google.ima.OmidAccessMode.FULL] = omidValues.FULL;
1401    }
1402    if (omidValues.DOMAIN) {
1403      adsRequest.omidAccessModeRules[google.ima.OmidAccessMode.DOMAIN] = omidValues.DOMAIN;
1404    }
1405    if (omidValues.LIMITED) {
1406      adsRequest.omidAccessModeRules[google.ima.OmidAccessMode.LIMITED] = omidValues.LIMITED;
1407    }
1408  }
1409
1410  adsRequest.linearAdSlotWidth = this.controller.getPlayerWidth();
1411  adsRequest.linearAdSlotHeight = this.controller.getPlayerHeight();
1412  adsRequest.nonLinearAdSlotWidth = this.controller.getSettings().nonLinearWidth || this.controller.getPlayerWidth();
1413  adsRequest.nonLinearAdSlotHeight = this.controller.getSettings().nonLinearHeight || this.controller.getPlayerHeight();
1414  adsRequest.setAdWillAutoPlay(this.controller.adsWillAutoplay());
1415  adsRequest.setAdWillPlayMuted(this.controller.adsWillPlayMuted());
1416
1417  // Populate the adsRequestproperties with those provided in the AdsRequest
1418  // object in the settings.
1419  let providedAdsRequest = this.controller.getSettings().adsRequest;
1420  if (providedAdsRequest && typeof providedAdsRequest === 'object') {
1421    Object.keys(providedAdsRequest).forEach(key => {
1422      adsRequest[key] = providedAdsRequest[key];
1423    });
1424  }
1425
1426  this.adsLoader.requestAds(adsRequest);
1427  this.controller.playerWrapper.vjsPlayer.trigger({
1428    type: 'ads-request',
1429    AdsRequest: adsRequest
1430  });
1431};
1432
1433/**
1434 * Listener for the ADS_MANAGER_LOADED event. Creates the AdsManager,

1543  this.adPlaying = false;
1544};
1545
1546/**
1547 * Listener for AD_BREAK_READY. Passes event on to publisher's listener.
1548 * @param {google.ima.AdEvent} adEvent AdEvent thrown by the AdsManager.
1549 */
1550SdkImpl.prototype.onAdBreakReady = function (adEvent) {
1551  this.adBreakReadyListener(adEvent);
1552};
1553
1554/**
1555 * Pauses the content video and displays the ad container so ads can play.
1556 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1557 */
1558SdkImpl.prototype.onContentPauseRequested = function (adEvent) {
1559  this.adsActive = true;
1560  this.adPlaying = true;
1561  this.controller.onAdBreakStart(adEvent);
1562};
1563
1564/**
1565 * Resumes content video and hides the ad container.
1566 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1567 */
1568SdkImpl.prototype.onContentResumeRequested = function (adEvent) {
1569  this.adsActive = false;
1570  this.adPlaying = false;
1571  this.controller.onAdBreakEnd();
1572  // Hide controls in case of future non-linear ads. They'll be unhidden in
1573  // content_pause_requested.
1574};
1575
1576/**
1577 * Records that ads have completed and calls contentAndAdsEndedListeners
1578 * if content is also complete.
1579 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1580 */
1581SdkImpl.prototype.onAllAdsCompleted = function (adEvent) {
1582  this.allAdsCompleted = true;
1583  this.controller.onAllAdsCompleted();
1584};
1585
1586/**
1587 * Starts the content video when a non-linear ad is loaded.
1588 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1589 */
1590SdkImpl.prototype.onAdLoaded = function (adEvent) {
1591  if (!adEvent.getAd().isLinear()) {
1592    this.controller.onNonLinearAdLoad();
1593    this.controller.playContent();
1594  }
1595};
1596
1597/**
1598 * Starts the interval timer to check the current ad time when an ad starts
1599 * playing.
1600 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1601 */
1602SdkImpl.prototype.onAdStarted = function (adEvent) {
1603  this.currentAd = adEvent.getAd();
1604  if (this.currentAd.isLinear()) {
1605    this.adTrackingTimer = setInterval(this.onAdPlayheadTrackerInterval.bind(this), 250);
1606    this.controller.onLinearAdStart();
1607  } else {
1608    this.controller.onNonLinearAdStart();
1609  }
1610};
1611
1612/**
1613 * Handles an ad click. Puts the player UI in a paused state.
1614 */
1615SdkImpl.prototype.onAdPaused = function () {
1616  this.controller.onAdsPaused();
1617};
1618
1619/**
1620 * Syncs controls when an ad resumes.
1621 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1622 */
1623SdkImpl.prototype.onAdResumed = function (adEvent) {
1624  this.controller.onAdsResumed();
1625};
1626
1627/**
1628 * Clears the interval timer for current ad time when an ad completes.
1629 */
1630SdkImpl.prototype.onAdComplete = function () {
1631  if (this.currentAd.isLinear()) {
1632    clearInterval(this.adTrackingTimer);
1633  }
1634};
1635
1636/**
1637 * Handles ad log messages.
1638 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the AdsManager.
1639 */
1640SdkImpl.prototype.onAdLog = function (adEvent) {
1641  this.controller.onAdLog(adEvent);
1642};
1643
1644/**
1645 * Gets the current time and duration of the ad and calls the method to
1646 * update the ad UI.
1647 */
1648SdkImpl.prototype.onAdPlayheadTrackerInterval = function () {
1649  if (this.adsManager === null) return;
1650  const remainingTime = this.adsManager.getRemainingTime();
1651  const duration = this.currentAd.getDuration();
1652  let currentTime = duration - remainingTime;
1653  currentTime = currentTime > 0 ? currentTime : 0;
1654  let totalAds = 0;
1655  let adPosition;
1656  if (this.currentAd.getAdPodInfo()) {
1657    adPosition = this.currentAd.getAdPodInfo().getAdPosition();
1658    totalAds = this.currentAd.getAdPodInfo().getTotalAds();
1659  }
1660
1661  this.controller.onAdPlayheadUpdated(currentTime, remainingTime, duration, adPosition, totalAds);
1662};
1663
1664/**
1665 * Called by the player wrapper when content completes.
1666 */
1667SdkImpl.prototype.onContentComplete = function () {
1668  if (this.adsLoader) {
1669    this.adsLoader.contentComplete();
1670    this.contentCompleteCalled = true;
1671  }
1672
1673  if (this.adsManager && this.adsManager.getCuePoints() && !this.adsManager.getCuePoints().includes(-1) || !this.adsManager) {
1674    this.controller.onNoPostroll();
1675  }
1676
1677  if (this.allAdsCompleted) {
1678    this.controller.onContentAndAdsCompleted();
1679  }
1680};
1681
1682/**
1683 * Called when the player is disposed.
1684 */
1685SdkImpl.prototype.onPlayerDisposed = function () {
1686  if (this.adTrackingTimer) {
1687    clearInterval(this.adTrackingTimer);
1688  }
1689  if (this.adsManager) {
1690    this.adsManager.destroy();
1691    this.adsManager = null;
1692  }
1693};
1694
1695SdkImpl.prototype.onPlayerReadyForPreroll = function () {
1696  if (this.autoPlayAdBreaks) {
1697    this.initAdsManager();
1698    try {
1699      this.controller.showAdContainer();
1700      // Sync ad volume with content volume.
1701      this.adsManager.setVolume(this.controller.getPlayerVolume());
1702      this.adsManager.start();
1703    } catch (adError) {
1704      this.onAdError(adError);
1705    }
1706  }
1707};
1708
1709SdkImpl.prototype.onAdTimeout = function () {
1710  this.isAdTimedOut = true;
1711};
1712
1713SdkImpl.prototype.onPlayerReady = function () {
1714  this.initAdObjects();
1715
1716  if ((this.controller.getSettings().adTagUrl || this.controller.getSettings().adsResponse) && this.controller.getSettings().requestMode === 'onLoad') {
1717    this.requestAds();
1718  }
1719};
1720
1721SdkImpl.prototype.onPlayerEnterFullscreen = function () {
1722  if (this.adsManager) {
1723    this.adsManager.resize(window.screen.width, window.screen.height, google.ima.ViewMode.FULLSCREEN);
1724  }
1725};
1726
1727SdkImpl.prototype.onPlayerExitFullscreen = function () {
1728  if (this.adsManager) {
1729    this.adsManager.resize(this.controller.getPlayerWidth(), this.controller.getPlayerHeight(), google.ima.ViewMode.NORMAL);
1730  }
1731};
1732
1733/**
1734 * Called when the player volume changes.
1735 *
1736 * @param {number} volume The new player volume.
1737 */
1738SdkImpl.prototype.onPlayerVolumeChanged = function (volume) {
1739  if (this.adsManager) {
1740    this.adsManager.setVolume(volume);
1741  }
1742
1743  if (volume == 0) {
1744    this.adMuted = true;
1745  } else {
1746    this.adMuted = false;
1747  }
1748};
1749
1750/**
1751 * Called when the player wrapper detects that the player has been resized.
1752 *
1753 * @param {number} width The post-resize width of the player.
1754 * @param {number} height The post-resize height of the player.
1755 */
1756SdkImpl.prototype.onPlayerResize = function (width, height) {
1757  if (this.adsManager) {
1758    this.adsManagerDimensions.width = width;
1759    this.adsManagerDimensions.height = height;
1760    /* eslint no-undef: 'error' */
1761    this.adsManager.resize(width, height, google.ima.ViewMode.NORMAL);
1762  }
1763};
1764
1765/**
1766 * @return {Object} The current ad.
1767 */
1768SdkImpl.prototype.getCurrentAd = function () {
1769  return this.currentAd;
1770};
1771
1772/**
1773 * Listener JSDoc for ESLint. This listener can be passed to
1774 * setAdBreakReadyListener.
1775 * @callback listener
1776 */
1777
1778/**
1779 * Sets the listener to be called to trigger manual ad break playback.
1780 * @param {listener} listener The listener to be called to trigger manual ad
1781 *     break playback.
1782 */
1783SdkImpl.prototype.setAdBreakReadyListener = function (listener) {
1784  this.adBreakReadyListener = listener;
1785};
1786
1787/**
1788 * @return {boolean} True if an ad is currently playing. False otherwise.
1789 */
1790SdkImpl.prototype.isAdPlaying = function () {
1791  return this.adPlaying;
1792};
1793
1794/**
1795 * @return {boolean} True if an ad is currently playing. False otherwise.
1796 */
1797SdkImpl.prototype.isAdMuted = function () {
1798  return this.adMuted;
1799};
1800
1801/**
1802 * Pause ads.
1803 */
1804SdkImpl.prototype.pauseAds = function () {
1805  this.adsManager.pause();
1806  this.adPlaying = false;
1807};
1808
1809/**
1810 * Resume ads.
1811 */
1812SdkImpl.prototype.resumeAds = function () {
1813  this.adsManager.resume();
1814  this.adPlaying = true;
1815};
1816
1817/**
1818 * Unmute ads.
1819 */
1820SdkImpl.prototype.unmute = function () {
1821  this.adsManager.setVolume(1);
1822  this.adMuted = false;
1823};
1824
1825/**
1826 * Mute ads.
1827 */
1828SdkImpl.prototype.mute = function () {
1829  this.adsManager.setVolume(0);
1830  this.adMuted = true;
1831};
1832
1833/**
1834 * Set the volume of the ads. 0-1.
1835 *
1836 * @param {number} volume The new volume.
1837 */
1838SdkImpl.prototype.setVolume = function (volume) {
1839  this.adsManager.setVolume(volume);
1840  if (volume == 0) {
1841    this.adMuted = true;
1842  } else {
1843    this.adMuted = false;
1844  }
1845};
1846
1847/**
1848 * Initializes the AdDisplayContainer. On mobile, this must be done as a
1849 * result of user action.
1850 */
1851SdkImpl.prototype.initializeAdDisplayContainer = function () {
1852  if (this.adDisplayContainer) {
1853    if (!this.adDisplayContainerInitialized) {
1854      this.adDisplayContainer.initialize();
1855      this.adDisplayContainerInitialized = true;
1856    }
1857  }
1858};
1859
1860/**
1861 * Called by publishers in manual ad break playback mode to start an ad
1862 * break.
1863 */
1864SdkImpl.prototype.playAdBreak = function () {
1865  if (!this.autoPlayAdBreaks) {
1866    this.controller.showAdContainer();
1867    // Sync ad volume with content volume.
1868    this.adsManager.setVolume(this.controller.getPlayerVolume());
1869    this.adsManager.start();
1870  }
1871};
1872
1873/**
1874 * Callback JSDoc for ESLint. This callback can be passed to addEventListener.
1875 * @callback callback
1876 */
1877
1878/**
1879 * Ads an EventListener to the AdsManager. For a list of available events,
1880 * see
1881 * https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/reference/js/google.ima.AdEvent#.Type
1882 * @param {google.ima.AdEvent.Type} event The AdEvent.Type for which to
1883 *     listen.
1884 * @param {callback} callback The method to call when the event is fired.
1885 */
1886SdkImpl.prototype.addEventListener = function (event, callback) {
1887  if (this.adsManager) {
1888    this.adsManager.addEventListener(event, callback);
1889  }
1890};
1891
1892/**
1893 * Returns the instance of the AdsManager.
1894 * @return {google.ima.AdsManager} The AdsManager being used by the plugin.
1895 */
1896SdkImpl.prototype.getAdsManager = function () {
1897  return this.adsManager;
1898};
1899
1900/**
1901 * Reset the SDK implementation.
1902 */
1903SdkImpl.prototype.reset = function () {
1904  this.adsActive = false;
1905  this.adPlaying = false;
1906  if (this.adTrackingTimer) {
1907    // If this is called while an ad is playing, stop trying to get that
1908    // ad's current time.
1909    clearInterval(this.adTrackingTimer);
1910  }
1911  if (this.adsManager) {
1912    this.adsManager.destroy();
1913    this.adsManager = null;
1914  }
1915  if (this.adsLoader && !this.contentCompleteCalled) {
1916    this.adsLoader.contentComplete();
1917  }
1918  this.contentCompleteCalled = false;
1919  this.allAdsCompleted = false;
1920};
1921
1922/**
1923 * Copyright 2017 Google Inc.
1924 *
1925 * Licensed under the Apache License, Version 2.0 (the "License");
1926 * you may not use this file except in compliance with the License.
1927 * You may obtain a copy of the License at
1928 *
1929 *     http://www.apache.org/licenses/LICENSE-2.0
1930 *
1931 * Unless required by applicable law or agreed to in writing, software
1932 * distributed under the License is distributed on an "AS IS" BASIS,
1933 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1934 * See the License for the specific language governing permissions and
1935 * limitations under the License.
1936 *
1937 * IMA SDK integration plugin for Video.js. For more information see
1938 * https://www.github.com/googleads/videojs-ima
1939 */
1940/**
1941 * The grand coordinator of the plugin. Facilitates communication between all
1942 * other plugin classes.
1943 *
1944 * @param {Object} player Instance of the video.js player.
1945 * @param {Object} options Options provided by the implementation.
1946 * @constructor
1947 * @struct
1948 * @final
1949 */
1950const Controller = function (player, options) {
1951  /**
1952   * Stores user-provided settings.
1953   * @type {Object}
1954   */
1955  this.settings = {};
1956
1957  /**
1958   * Content and ads ended listeners passed by the publisher to the plugin.
1959   * These will be called when the plugin detects that content *and all
1960   * ads* have completed. This differs from the contentEndedListeners in that
1961   * contentEndedListeners will fire between content ending and a post-roll
1962   * playing, whereas the contentAndAdsEndedListeners will fire after the
1963   * post-roll completes.
1964   */
1965  this.contentAndAdsEndedListeners = [];
1966
1967  /**
1968   * Whether or not we are running on a mobile platform.
1969   */
1970  this.isMobile = navigator.userAgent.match(/iPhone/i) || navigator.userAgent.match(/iPad/i) || navigator.userAgent.match(/Android/i);
1971
1972  /**
1973   * Whether or not we are running on an iOS platform.
1974   */
1975  this.isIos = navigator.userAgent.match(/iPhone/i) || navigator.userAgent.match(/iPad/i);
1976
1977  this.initWithSettings(options);
1978
1979  /**
1980   * Stores contrib-ads default settings.
1981   */
1982  const contribAdsDefaults = {
1983    debug: this.settings.debug,
1984    timeout: this.settings.timeout,
1985    prerollTimeout: this.settings.prerollTimeout
1986  };
1987  const adsPluginSettings = Object.assign({}, contribAdsDefaults, options.contribAdsSettings || {});
1988
1989  this.playerWrapper = new PlayerWrapper(player, adsPluginSettings, this);
1990  this.adUi = new AdUi(this);
1991  this.sdkImpl = new SdkImpl(this);
1992};
1993
1994Controller.IMA_DEFAULTS = {
1995  adLabel: 'Advertisement',
1996  adLabelNofN: 'of',
1997  debug: false,
1998  disableAdControls: false,
1999  prerollTimeout: 1000,
2000  preventLateAdStart: false,
2001  requestMode: 'onLoad',
2002  showControlsForJSAds: true,
2003  timeout: 5000
2004};
2005
2006/**
2007 * Extends the settings to include user-provided settings.
2008 *
2009 * @param {Object} options Options to be used in initialization.
2010 */
2011Controller.prototype.initWithSettings = function (options) {
2012  this.settings = Object.assign({}, Controller.IMA_DEFAULTS, options || {});
2013
2014  this.warnAboutDeprecatedSettings();
2015
2016  // Default showing countdown timer to true.
2017  this.showCountdown = true;
2018  if (this.settings.showCountdown === false) {
2019    this.showCountdown = false;
2020  }
2021};
2022
2023/**
2024 * Logs console warnings when deprecated settings are used.
2025 */
2026Controller.prototype.warnAboutDeprecatedSettings = function () {
2027  const deprecatedSettings = ['adWillAutoplay', 'adsWillAutoplay', 'adWillPlayMuted', 'adsWillPlayMuted'];
2028  deprecatedSettings.forEach(setting => {
2029    if (this.settings[setting] !== undefined) {
2030      console.warn('WARNING: videojs.ima setting ' + setting + ' is deprecated');
2031    }
2032  });
2033};
2034
2035/**
2036 * Return the settings object.
2037 *
2038 * @return {Object} The settings object.
2039 */
2040Controller.prototype.getSettings = function () {
2041  return this.settings;
2042};
2043
2044/**
2045 * Return whether or not we're in a mobile environment.
2046 *
2047 * @return {boolean} True if running on mobile, false otherwise.
2048 */
2049Controller.prototype.getIsMobile = function () {
2050  return this.isMobile;
2051};
2052
2053/**
2054 * Return whether or not we're in an iOS environment.
2055 *
2056 * @return {boolean} True if running on iOS, false otherwise.
2057 */
2058Controller.prototype.getIsIos = function () {
2059  return this.isIos;
2060};
2061
2062/**
2063 * Inject the ad container div into the DOM.
2064 *
2065 * @param{HTMLElement} adContainerDiv The ad container div.
2066 */
2067Controller.prototype.injectAdContainerDiv = function (adContainerDiv) {
2068  this.playerWrapper.injectAdContainerDiv(adContainerDiv);
2069};
2070
2071/**
2072 * @return {HTMLElement} The div for the ad container.
2073 */
2074Controller.prototype.getAdContainerDiv = function () {
2075  return this.adUi.getAdContainerDiv();
2076};
2077
2078/**
2079 * @return {Object} The content player.
2080 */
2081Controller.prototype.getContentPlayer = function () {
2082  return this.playerWrapper.getContentPlayer();
2083};
2084
2085/**
2086 * Returns the content playhead tracker.
2087 *
2088 * @return {Object} The content playhead tracker.
2089 */
2090Controller.prototype.getContentPlayheadTracker = function () {
2091  return this.playerWrapper.getContentPlayheadTracker();
2092};
2093
2094/**
2095 * Requests ads.
2096 */
2097Controller.prototype.requestAds = function () {
2098  this.sdkImpl.requestAds();
2099};
2100
2101/**
2102 * Add or modify a setting.
2103 *
2104 * @param {string} key Key to modify
2105 * @param {Object} value Value to set at key.
2106 */
2107Controller.prototype.setSetting = function (key, value) {
2108  this.settings[key] = value;
2109};
2110
2111/**
2112 * Called when there is an error loading ads.
2113 *
2114 * @param {Object} adErrorEvent The ad error event thrown by the IMA SDK.
2115 */
2116Controller.prototype.onErrorLoadingAds = function (adErrorEvent) {
2117  this.adUi.onAdError();
2118  this.playerWrapper.onAdError(adErrorEvent);
2119};
2120
2121/**
2122 * Called by the ad UI when the play/pause button is clicked.
2123 */
2124Controller.prototype.onAdPlayPauseClick = function () {
2125  if (this.sdkImpl.isAdPlaying()) {
2126    this.adUi.onAdsPaused();
2127    this.sdkImpl.pauseAds();
2128  } else {
2129    this.adUi.onAdsPlaying();
2130    this.sdkImpl.resumeAds();
2131  }
2132};
2133
2134/**
2135 * Called by the ad UI when the mute button is clicked.
2136 *
2137 */
2138Controller.prototype.onAdMuteClick = function () {
2139  if (this.sdkImpl.isAdMuted()) {
2140    this.playerWrapper.unmute();
2141    this.adUi.unmute();
2142    this.sdkImpl.unmute();
2143  } else {
2144    this.playerWrapper.mute();
2145    this.adUi.mute();
2146    this.sdkImpl.mute();
2147  }
2148};
2149
2150/**
2151 * Set the volume of the player and ads. 0-1.
2152 *
2153 * @param {number} volume The new volume.
2154 */
2155Controller.prototype.setVolume = function (volume) {
2156  this.playerWrapper.setVolume(volume);
2157  this.sdkImpl.setVolume(volume);
2158};
2159
2160/**
2161 * @return {number} The volume of the content player.
2162 */
2163Controller.prototype.getPlayerVolume = function () {
2164  return this.playerWrapper.getVolume();
2165};
2166
2167/**
2168 * Toggle fullscreen state.
2169 */
2170Controller.prototype.toggleFullscreen = function () {
2171  this.playerWrapper.toggleFullscreen();
2172};
2173
2174/**
2175 * Relays ad errors to the player wrapper.
2176 *
2177 * @param {Object} adErrorEvent The ad error event thrown by the IMA SDK.
2178 */
2179Controller.prototype.onAdError = function (adErrorEvent) {
2180  this.adUi.onAdError();
2181  this.playerWrapper.onAdError(adErrorEvent);
2182};
2183
2184/**
2185 * Handles ad break starting.
2186 *
2187 * @param {Object} adEvent The event fired by the IMA SDK.
2188 */
2189Controller.prototype.onAdBreakStart = function (adEvent) {
2190  this.playerWrapper.onAdBreakStart();
2191  this.adUi.onAdBreakStart(adEvent);
2192};
2193
2194/**
2195 * Show the ad container.
2196 */
2197Controller.prototype.showAdContainer = function () {
2198  this.adUi.showAdContainer();
2199};
2200
2201/**
2202 * Handles ad break ending.
2203 */
2204Controller.prototype.onAdBreakEnd = function () {
2205  this.playerWrapper.onAdBreakEnd();
2206  this.adUi.onAdBreakEnd();
2207};
2208
2209/**
2210 * Handles when all ads have finished playing.
2211 */
2212Controller.prototype.onAllAdsCompleted = function () {
2213  this.adUi.onAllAdsCompleted();
2214  this.playerWrapper.onAllAdsCompleted();
2215};
2216
2217/**
2218 * Handles the SDK firing an ad paused event.
2219 */
2220Controller.prototype.onAdsPaused = function () {
2221  this.adUi.onAdsPaused();
2222};
2223
2224/**
2225 * Handles the SDK firing an ad resumed event.
2226 */
2227Controller.prototype.onAdsResumed = function () {
2228  this.adUi.onAdsResumed();
2229};
2230
2231/**
2232 * Takes data from the sdk impl and passes it to the ad UI to update the UI.
2233 *
2234 * @param {number} currentTime Current time of the ad.
2235 * @param {number} remainingTime Remaining time of the ad.
2236 * @param {number} duration Duration of the ad.
2237 * @param {number} adPosition Index of the ad in the pod.
2238 * @param {number} totalAds Total number of ads in the pod.
2239 */
2240Controller.prototype.onAdPlayheadUpdated = function (currentTime, remainingTime, duration, adPosition, totalAds) {
2241  this.adUi.updateAdUi(currentTime, remainingTime, duration, adPosition, totalAds);
2242};
2243
2244/**
2245 * Handles ad log messages.
2246 * @param {google.ima.AdEvent} adEvent The AdEvent thrown by the IMA SDK.
2247 */
2248Controller.prototype.onAdLog = function (adEvent) {
2249  this.playerWrapper.onAdLog(adEvent);
2250};
2251
2252/**
2253 * @return {Object} The current ad.
2254 */
2255Controller.prototype.getCurrentAd = function () {
2256  return this.sdkImpl.getCurrentAd();
2257};
2258
2259/**
2260 * Play content.
2261 */
2262Controller.prototype.playContent = function () {
2263  this.playerWrapper.play();
2264};
2265
2266/**
2267 * Handles when a linear ad starts.
2268 */
2269Controller.prototype.onLinearAdStart = function () {
2270  this.adUi.onLinearAdStart();
2271  this.playerWrapper.onAdStart();
2272};
2273
2274/**
2275 * Handles when a non-linear ad loads.
2276 */
2277Controller.prototype.onNonLinearAdLoad = function () {
2278  this.adUi.onNonLinearAdLoad();
2279};
2280
2281/**
2282 * Handles when a non-linear ad starts.
2283 */
2284Controller.prototype.onNonLinearAdStart = function () {
2285  this.adUi.onNonLinearAdLoad();
2286  this.playerWrapper.onAdStart();
2287};
2288
2289/**
2290 * Get the player width.
2291 *
2292 * @return {number} The width of the player.
2293 */
2294Controller.prototype.getPlayerWidth = function () {
2295  return this.playerWrapper.getPlayerWidth();
2296};
2297
2298/**
2299 * Get the player height.
2300 *
2301 * @return {number} The height of the player.
2302 */
2303Controller.prototype.getPlayerHeight = function () {
2304  return this.playerWrapper.getPlayerHeight();
2305};
2306
2307/**
2308 * Tells the player wrapper that ads are ready.
2309 */
2310Controller.prototype.onAdsReady = function () {
2311  this.playerWrapper.onAdsReady();
2312};
2313
2314/**
2315 * Called when the player wrapper detects that the player has been resized.
2316 *
2317 * @param {number} width The post-resize width of the player.
2318 * @param {number} height The post-resize height of the player.
2319 */
2320Controller.prototype.onPlayerResize = function (width, height) {
2321  this.sdkImpl.onPlayerResize(width, height);
2322};
2323
2324/**
2325 * Called by the player wrapper when content completes.
2326 */
2327Controller.prototype.onContentComplete = function () {
2328  this.sdkImpl.onContentComplete();
2329};
2330
2331/**
2332 * Called by the player wrapper when it's time to play a post-roll but we don't
2333 * have one to play.
2334 */
2335Controller.prototype.onNoPostroll = function () {
2336  this.playerWrapper.onNoPostroll();
2337};
2338
2339/**
2340 * Called when content and all ads have completed.
2341 */
2342Controller.prototype.onContentAndAdsCompleted = function () {
2343  for (let index in this.contentAndAdsEndedListeners) {
2344    if (typeof this.contentAndAdsEndedListeners[index] === 'function') {
2345      this.contentAndAdsEndedListeners[index]();
2346    }
2347  }
2348};
2349
2350/**
2351 * Called when the player is disposed.
2352 */
2353Controller.prototype.onPlayerDisposed = function () {
2354  this.contentAndAdsEndedListeners = [];
2355  this.sdkImpl.onPlayerDisposed();
2356};
2357
2358/**
2359 * Called when the player is ready to play a pre-roll.
2360 */
2361Controller.prototype.onPlayerReadyForPreroll = function () {
2362  this.sdkImpl.onPlayerReadyForPreroll();
2363};
2364
2365/**
2366 * Called if the ad times out.
2367 */
2368Controller.prototype.onAdTimeout = function () {
2369  this.sdkImpl.onAdTimeout();
2370};
2371
2372/**
2373 * Called when the player is ready.
2374 */
2375Controller.prototype.onPlayerReady = function () {
2376  this.sdkImpl.onPlayerReady();
2377};
2378
2379/**
2380 * Called when the player enters fullscreen.
2381 */
2382Controller.prototype.onPlayerEnterFullscreen = function () {
2383  this.adUi.onPlayerEnterFullscreen();
2384  this.sdkImpl.onPlayerEnterFullscreen();
2385};
2386
2387/**
2388 * Called when the player exits fullscreen.
2389 */
2390Controller.prototype.onPlayerExitFullscreen = function () {
2391  this.adUi.onPlayerExitFullscreen();
2392  this.sdkImpl.onPlayerExitFullscreen();
2393};
2394
2395/**
2396 * Called when the player volume changes.
2397 *
2398 * @param {number} volume The new player volume.
2399 */
2400Controller.prototype.onPlayerVolumeChanged = function (volume) {
2401  this.adUi.onPlayerVolumeChanged(volume);
2402  this.sdkImpl.onPlayerVolumeChanged(volume);
2403};
2404
2405/**
2406 * Sets the content of the video player. You should use this method instead
2407 * of setting the content src directly to ensure the proper ad tag is
2408 * requested when the video content is loaded.
2409 * @param {?string} contentSrc The URI for the content to be played. Leave
2410 *     blank to use the existing content.
2411 * @param {?string} adTag The ad tag to be requested when the content loads.
2412 *     Leave blank to use the existing ad tag.
2413 */
2414Controller.prototype.setContentWithAdTag = function (contentSrc, adTag) {
2415  this.reset();
2416  this.settings.adTagUrl = adTag ? adTag : this.settings.adTagUrl;
2417  this.playerWrapper.changeSource(contentSrc);
2418};
2419
2420/**
2421 * Sets the content of the video player. You should use this method instead
2422 * of setting the content src directly to ensure the proper ads response is
2423 * used when the video content is loaded.
2424 * @param {?string} contentSrc The URI for the content to be played. Leave
2425 *     blank to use the existing content.
2426 * @param {?string} adsResponse The ads response to be requested when the
2427 *     content loads. Leave blank to use the existing ads response.
2428 */
2429Controller.prototype.setContentWithAdsResponse = function (contentSrc, adsResponse) {
2430  this.reset();
2431  this.settings.adsResponse = adsResponse ? adsResponse : this.settings.adsResponse;
2432  this.playerWrapper.changeSource(contentSrc);
2433};
2434
2435/**
2436 * Sets the content of the video player. You should use this method instead
2437 * of setting the content src directly to ensure the proper ads request is
2438 * used when the video content is loaded.
2439 * @param {?string} contentSrc The URI for the content to be played. Leave
2440 *     blank to use the existing content.
2441 * @param {?Object} adsRequest The ads request to be requested when the
2442 *     content loads. Leave blank to use the existing ads request.
2443 */
2444Controller.prototype.setContentWithAdsRequest = function (contentSrc, adsRequest) {
2445  this.reset();
2446  this.settings.adsRequest = adsRequest ? adsRequest : this.settings.adsRequest;
2447  this.playerWrapper.changeSource(contentSrc);
2448};
2449
2450/**
2451 * Resets the state of the plugin.
2452 */
2453Controller.prototype.reset = function () {
2454  this.sdkImpl.reset();
2455  this.playerWrapper.reset();
2456  this.adUi.reset();
2457};
2458
2459/**
2460 * Listener JSDoc for ESLint. This listener can be passed to
2461 * (add|remove)ContentEndedListener.
2462 * @callback listener
2463 */
2464
2465/**
2466 * Adds a listener for the 'contentended' event of the video player. This should
2467 * be used instead of setting an 'contentended' listener directly to ensure that
2468 * the ima can do proper cleanup of the SDK before other event listeners are
2469 * called.
2470 * @param {listener} listener The listener to be called when content
2471 *     completes.
2472 */
2473Controller.prototype.addContentEndedListener = function (listener) {
2474  this.playerWrapper.addContentEndedListener(listener);
2475};
2476
2477/**
2478 * Adds a listener that will be called when content and all ads have
2479 * finished playing.
2480 * @param {listener} listener The listener to be called when content and ads
2481 *     complete.
2482 */
2483Controller.prototype.addContentAndAdsEndedListener = function (listener) {
2484  this.contentAndAdsEndedListeners.push(listener);
2485};
2486
2487/**
2488 * Sets the listener to be called to trigger manual ad break playback.
2489 * @param {listener} listener The listener to be called to trigger manual ad
2490 *     break playback.
2491 */
2492Controller.prototype.setAdBreakReadyListener = function (listener) {
2493  this.sdkImpl.setAdBreakReadyListener(listener);
2494};
2495
2496/**
2497 * Changes the flag to show or hide the ad countdown timer.
2498 *
2499 * @param {boolean} showCountdownIn Show or hide the countdown timer.
2500 */
2501Controller.prototype.setShowCountdown = function (showCountdownIn) {
2502  this.adUi.setShowCountdown(showCountdownIn);
2503  this.showCountdown = showCountdownIn;
2504  this.adUi.countdownDiv.style.display = this.showCountdown ? 'block' : 'none';
2505};
2506
2507/**
2508 * Initializes the AdDisplayContainer. On mobile, this must be done as a
2509 * result of user action.
2510 */
2511Controller.prototype.initializeAdDisplayContainer = function () {
2512  this.sdkImpl.initializeAdDisplayContainer();
2513};
2514
2515/**
2516 * Called by publishers in manual ad break playback mode to start an ad
2517 * break.
2518 */
2519Controller.prototype.playAdBreak = function () {
2520  this.sdkImpl.playAdBreak();
2521};
2522
2523/**
2524 * Callback JSDoc for ESLint. This callback can be passed to addEventListener.
2525 * @callback callback
2526 */
2527
2528/**
2529 * Ads an EventListener to the AdsManager. For a list of available events,
2530 * see
2531 * https://developers.google.com/interactive-media-ads/docs/sdks/html5/client-side/reference/js/google.ima.AdEvent#.Type
2532 * @param {google.ima.AdEvent.Type} event The AdEvent.Type for which to
2533 *     listen.
2534 * @param {callback} callback The method to call when the event is fired.
2535 */
2536Controller.prototype.addEventListener = function (event, callback) {
2537  this.sdkImpl.addEventListener(event, callback);
2538};
2539
2540/**
2541 * Returns the instance of the AdsManager.
2542 * @return {google.ima.AdsManager} The AdsManager being used by the plugin.
2543 */
2544Controller.prototype.getAdsManager = function () {
2545  return this.sdkImpl.getAdsManager();
2546};
2547
2548/**
2549 * Returns the instance of the player id.
2550 * @return {string} The player id.
2551 */
2552Controller.prototype.getPlayerId = function () {
2553  return this.playerWrapper.getPlayerId();
2554};
2555
2556/**
2557 * Changes the ad tag. You will need to call requestAds after this method
2558 * for the new ads to be requested.
2559 * @param {?string} adTag The ad tag to be requested the next time
2560 *     requestAds is called.
2561 */
2562Controller.prototype.changeAdTag = function (adTag) {
2563  this.reset();
2564  this.settings.adTagUrl = adTag;
2565};
2566
2567/**
2568 * Pauses the ad.
2569 */
2570Controller.prototype.pauseAd = function () {
2571  this.adUi.onAdsPaused();
2572  this.sdkImpl.pauseAds();
2573};
2574
2575/**
2576 * Resumes the ad.
2577 */
2578Controller.prototype.resumeAd = function () {
2579  this.adUi.onAdsPlaying();
2580  this.sdkImpl.resumeAds();
2581};
2582
2583/**
2584 * Toggles video/ad playback.
2585 */
2586Controller.prototype.togglePlayback = function () {
2587  this.playerWrapper.togglePlayback();
2588};
2589
2590/**
2591 * @return {boolean} true if we expect that ads will autoplay. false otherwise.
2592 */
2593Controller.prototype.adsWillAutoplay = function () {
2594  if (this.settings.adsWillAutoplay !== undefined) {
2595    return this.settings.adsWillAutoplay;
2596  } else if (this.settings.adWillAutoplay !== undefined) {
2597    return this.settings.adWillAutoplay;
2598  } else {
2599    return !!this.playerWrapper.getPlayerOptions().autoplay;
2600  }
2601};
2602
2603/**
2604 * @return {boolean} true if we expect that ads will autoplay. false otherwise.
2605 */
2606Controller.prototype.adsWillPlayMuted = function () {
2607  if (this.settings.adsWillPlayMuted !== undefined) {
2608    return this.settings.adsWillPlayMuted;
2609  } else if (this.settings.adWillPlayMuted !== undefined) {
2610    return this.settings.adWillPlayMuted;
2611  } else if (this.playerWrapper.getPlayerOptions().muted !== undefined) {
2612    return this.playerWrapper.getPlayerOptions().muted;
2613  } else {
2614    return this.playerWrapper.getVolume() == 0;
2615  }
2616};
2617
2618/**
2619 * Triggers an event on the VJS player
2620 * @param  {string} name The event name.
2621 * @param  {Object} data The event data.
2622 */
2623Controller.prototype.triggerPlayerEvent = function (name, data) {
2624  this.playerWrapper.triggerPlayerEvent(name, data);
2625};
2626
2627/**
2628 * Copyright 2021 Google Inc.
2629 *
2630 * Licensed under the Apache License, Version 2.0 (the "License");