shaka-player 4.0.2 → 4.1.0

package/docs/design/chromecast.md

@@ -26,11 +26,13 @@ the `Player` and `HTMLMediaElement` objects.  Receiver apps only have to worry
 about their UI, while the `CastReceiver` takes care of playback and
 communication.
 
+To enable an Android (TV) receiver apps set `androidReceiverCompatible` to true.
+
 
 #### `CastProxy` API sketch
 
 ```js
-new shaka.cast.CastProxy(video, player, receiverAppId)
+new shaka.cast.CastProxy(video, player, receiverAppId, androidReceiverCompatible)
 
 // Also destroys the underlying local Player object
 shaka.cast.CastProxy.prototype.destroy() => Promise

package/docs/tutorials/drm-config.md

@@ -75,6 +75,22 @@ player.configure({
 If the browser supports it and you configured a license server URL for it, we'll
 use it.
 
+Alternative there are a config for make a mapping of keysystem if you know that
+is broadly supported. For example, `com.microsoft.playready.recommendation`:
+
+```js
+player.configure({
+  drm: {
+    keySystemsMapping: {
+      'com.microsoft.playready': 'com.microsoft.playready.recommendation',
+    }
+  }
+});
+```
+
+With the previous configuration you will choose the `recommendation` keySystem
+when your manifest (HLS or DASH) uses PlayReady.
+
 
 #### Clear Key
 

package/docs/tutorials/ui.md

@@ -130,6 +130,23 @@ Next, let's add a listener to the 'caststatuschanged' event in myapp.js:
   }
 ```
 
+
+#### Enabling Android Receiver Apps
+
+If you'd like to take advantage of Android Receiver App support,
+you will need to provide a boolean flag to enable support for
+casting to an Android receiver app.
+
+```html
+    <div data-shaka-player-container style="max-width:40em"
+         data-shaka-player-cast-receiver-id="E7271BEC"
+         data-shaka-player-cast-android-receiver-compatible="true">
+      <!-- The manifest url in the src attribute will be automatically loaded -->
+      <video autoplay data-shaka-player id="video" style="width:100%;height:100%"
+       src="https://storage.googleapis.com/shaka-demo-assets/angel-one/dash.mpd"></video>
+    </div
+
+
 #### Providing source(s) for auto load.
 
 It's also possible to provide the `src` attribute on the `<video>` element
@@ -200,6 +217,15 @@ const controls = ui.getControls();
 // your API calls will be routed to the remote playback session.
 const player = controls.getPlayer();
 const video = controls.getVideo();
+
+// Programatically configure the Chromecast Receiver App Id and Android
+// Receiver Compatability.
+ui.configure({
+  // Set the castReceiverAppId
+  'castReceiverAppId': 'BBED8D28',
+  // Enable casting to native Android Apps (e.g. Android TV Apps)
+  'castAndroidReceiverCompatible': true,
+});
 ```
 
 

package/externs/chromecast.js

@@ -270,6 +270,13 @@ chrome.cast.Session = class {
 
 
 chrome.cast.SessionRequest = class {
-  /** @param {string} appId */
-  constructor(appId) {}
+  /**
+   * @param {string} appId
+   * @param {Array.<Object>} capabilities
+   * @param {?number} timeout
+   * @param {boolean} androidReceiverCompatible
+   * @param {Object} credentialsData
+   */
+  constructor(appId, capabilities, timeout, androidReceiverCompatible,
+      credentialsData) {}
 };

package/externs/shaka/manifest.js

@@ -176,6 +176,7 @@ shaka.extern.DrmInfo;
  * @typedef {{
  *   id: number,
  *   language: string,
+ *   disabledUntilTime: number,
  *   primary: boolean,
  *   audio: ?shaka.extern.Stream,
  *   video: ?shaka.extern.Stream,
@@ -198,6 +199,12 @@ shaka.extern.DrmInfo;
  *   The Variant's language, specified as a language code. <br>
  *   See {@link https://tools.ietf.org/html/rfc5646} <br>
  *   See {@link http://www.iso.org/iso/home/standards/language_codes.htm}
+ * @property {number} disabledUntilTime
+ *   <i>Defaults to 0.</i> <br>
+ *   0 means the variant is enabled. The Player will set this value to
+ *   "(Date.now() / 1000) + config.streaming.maxDisabledTime" and once this
+ *   maxDisabledTime has passed Player will set the value to 0 in order to
+ *   reenable the variant.
  * @property {boolean} primary
  *   <i>Defaults to false.</i> <br>
  *   True indicates that the player should use this Variant over others if user

package/externs/shaka/player.js

@@ -82,6 +82,9 @@ shaka.extern.StateChange;
  *
  *   maxSegmentDuration: number,
  *
+ *   gapsJumped: number,
+ *   stallsDetected: number,
+ *
  *   switchHistory: !Array.<shaka.extern.TrackChoice>,
  *   stateHistory: !Array.<shaka.extern.StateChange>
  * }}
@@ -112,6 +115,11 @@ shaka.extern.StateChange;
  * @property {number} estimatedBandwidth
  *   The current estimated network bandwidth (in bit/sec).
  *
+ * @property {number} gapsJumped
+ *   The total number of playback gaps jumped by the GapJumpingController.
+ * @property {number} stallsDetected
+ *   The total number of playback stalls detected by the StallDetector.
+ *
  * @property {number} completionPercent
  *   This is the greatest completion percent that the user has experienced in
  *   playback.  Also known as the "high water mark".  Is NaN when there is no
@@ -623,7 +631,8 @@ shaka.extern.AdvancedDrmConfiguration;
  *         undefined),
  *   logLicenseExchange: boolean,
  *   updateExpirationTime: number,
- *   preferredKeySystems: !Array.<string>
+ *   preferredKeySystems: !Array.<string>,
+ *   keySystemsMapping: !Object.<string, string>
  * }}
  *
  * @property {shaka.extern.RetryParameters} retryParameters
@@ -664,6 +673,8 @@ shaka.extern.AdvancedDrmConfiguration;
  * @property {!Array.<string>} preferredKeySystems
  *   <i>Defaults to an empty array. </i> <br>
  *   Specifies the priorties of available DRM key systems.
+ * @property {Object.<string, string>} keySystemsMapping
+ *   A map of key system name to key system name.
  *
  * @exportDoc
  */
@@ -863,7 +874,8 @@ shaka.extern.ManifestConfiguration;
  *   preferNativeHls: boolean,
  *   updateIntervalSeconds: number,
  *   dispatchAllEmsgBoxes: boolean,
- *   observeQualityChanges: boolean
+ *   observeQualityChanges: boolean,
+ *   maxDisabledTime: number
  * }}
  *
  * @description
@@ -968,6 +980,10 @@ shaka.extern.ManifestConfiguration;
  * @property {boolean} observeQualityChanges
  *   If true, monitor media quality changes and emit
  *   <code.shaka.Player.MediaQualityChangedEvent</code>.
+ * @property {number} maxDisabledTime
+ *   The maximum time a variant can be disabled when NETWORK HTTP_ERROR
+ *   is reached, in seconds.
+ *   If all variants are disabled this way, NETWORK HTTP_ERROR will be thrown.
  * @exportDoc
  */
 shaka.extern.StreamingConfiguration;
@@ -1264,11 +1280,14 @@ shaka.extern.Thumbnail;
 
 /**
  * @typedef {{
+ *   id: string,
  *   title: string,
  *   startTime: number,
  *   endTime: number
  * }}
  *
+ * @property {string} id
+ *    The id of the chapter.
  * @property {string} title
  *    The title of the chapter.
  * @property {number} startTime

package/externs/shaka/text.js

@@ -297,6 +297,13 @@ shaka.extern.Cue = class {
      */
     this.fontFamily;
 
+    /**
+     * Text shadow color as a CSS text-shadow value.
+     * @type {string}
+     * @exportDoc
+     */
+    this.textShadow = '';
+
     /**
      * Text stroke color as a CSS color, e.g. "#FFFFFF" or "white".
      * @type {string}

package/lib/cast/cast_proxy.js

@@ -43,8 +43,11 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
    * @param {string} receiverAppId The ID of the cast receiver application.
    *   If blank, casting will not be available, but the proxy will still
    *   function otherwise.
+   * @param {boolean} androidReceiverCompatible Indicates if the app is
+   *   compatible with an Android Receiver.
    */
-  constructor(video, player, receiverAppId) {
+  constructor(video, player, receiverAppId,
+      androidReceiverCompatible = false) {
     super();
 
     /** @private {HTMLMediaElement} */
@@ -71,6 +74,9 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
     /** @private {string} */
     this.receiverAppId_ = receiverAppId;
 
+    /** @private {boolean} */
+    this.androidReceiverCompatible_ = androidReceiverCompatible;
+
     /** @private {!Map} */
     this.compiledToExternNames_ = new Map();
 
@@ -81,7 +87,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
         () => this.onFirstCastStateUpdate_(),
         (targetName, event) => this.onRemoteEvent_(targetName, event),
         () => this.onResumeLocal_(),
-        () => this.getInitState_());
+        () => this.getInitState_(),
+        androidReceiverCompatible);
 
 
     this.init_();
@@ -225,15 +232,18 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
 
   /**
    * @param {string} newAppId
+   * @param {boolean=} newCastAndroidReceiver
    * @export
    */
-  async changeReceiverId(newAppId) {
-    if (newAppId == this.receiverAppId_) {
+  async changeReceiverId(newAppId, newCastAndroidReceiver = false) {
+    if (newAppId == this.receiverAppId_ &&
+        newCastAndroidReceiver == this.androidReceiverCompatible_) {
       // Nothing to change
       return;
     }
 
     this.receiverAppId_ = newAppId;
+    this.androidReceiverCompatible_ = newCastAndroidReceiver;
 
     // Destroy the old sender
     this.sender_.forceDisconnect();
@@ -248,7 +258,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
         () => this.onFirstCastStateUpdate_(),
         (targetName, event) => this.onRemoteEvent_(targetName, event),
         () => this.onResumeLocal_(),
-        () => this.getInitState_());
+        () => this.getInitState_(),
+        newCastAndroidReceiver);
 
     this.sender_.init();
   }
@@ -267,8 +278,8 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
           (event) => this.videoProxyLocalEvent_(event));
     }
 
-    for (const key in shaka.Player.EventName) {
-      const name = shaka.Player.EventName[key];
+    for (const key in shaka.util.FakeEvent.EventName) {
+      const name = shaka.util.FakeEvent.EventName[key];
       this.eventManager_.listen(this.localPlayer_, name,
           (event) => this.playerProxyLocalEvent_(event));
     }
@@ -526,7 +537,7 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
       // Pass any errors through to the app.
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Wrong error type!');
-      const eventType = shaka.Player.EventName.Error;
+      const eventType = shaka.util.FakeEvent.EventName.Error;
       const data = (new Map()).set('detail', error);
       const event = new shaka.util.FakeEvent(eventType, data);
       this.localPlayer_.dispatchEvent(event);

package/lib/cast/cast_receiver.js

@@ -281,8 +281,8 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
           this.video_, name, (event) => this.proxyEvent_('video', event));
     }
 
-    for (const key in shaka.Player.EventName) {
-      const name = shaka.Player.EventName[key];
+    for (const key in shaka.util.FakeEvent.EventName) {
+      const name = shaka.util.FakeEvent.EventName[key];
       this.eventManager_.listen(
           this.player_, name, (event) => this.proxyEvent_('player', event));
     }
@@ -409,7 +409,7 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
         // Pass any errors through to the app.
         goog.asserts.assert(error instanceof shaka.util.Error,
             'Wrong error type!');
-        const eventType = shaka.Player.EventName.Error;
+        const eventType = shaka.util.FakeEvent.EventName.Error;
         const data = (new Map()).set('detail', error);
         const event = new shaka.util.FakeEvent(eventType, data);
         // Only dispatch the event if the player still exists.

package/lib/cast/cast_sender.js

@@ -32,12 +32,18 @@ shaka.cast.CastSender = class {
    *   should resume playback.  Called before the cached remote state is wiped.
    * @param {function()} onInitStateRequired A callback to get local player's.
    *   state.  Invoked when casting is initiated from Chrome's cast button.
+   * @param {boolean} androidReceiverCompatible Indicates if the app is
+   *   compatible with an Android Receiver.
    */
   constructor(receiverAppId, onStatusChanged, onFirstCastStateUpdate,
-      onRemoteEvent, onResumeLocal, onInitStateRequired) {
+      onRemoteEvent, onResumeLocal, onInitStateRequired,
+      androidReceiverCompatible) {
     /** @private {string} */
     this.receiverAppId_ = receiverAppId;
 
+    /** @private {boolean} */
+    this.androidReceiverCompatible_ = androidReceiverCompatible;
+
     /** @private {shaka.util.Timer} */
     this.statusChangeTimer_ = new shaka.util.Timer(onStatusChanged);
 
@@ -211,7 +217,11 @@ shaka.cast.CastSender = class {
     // Use static versions of the API callbacks, since the ChromeCast API is
     // static. If we used local versions, we might end up retaining references
     // to destroyed players here.
-    const sessionRequest = new chrome.cast.SessionRequest(this.receiverAppId_);
+    const sessionRequest = new chrome.cast.SessionRequest(this.receiverAppId_,
+        /* capabilities= */ [],
+        /* timeout= */ null,
+        this.androidReceiverCompatible_,
+        /* credentialsData= */null);
     const apiConfig = new chrome.cast.ApiConfig(sessionRequest,
         (session) => CastSender.onExistingSessionJoined_(session),
         (availability) => CastSender.onReceiverStatusChanged_(availability),

package/lib/hls/hls_parser.js

@@ -460,6 +460,7 @@ shaka.hls.HlsParser = class {
       variants.push({
         id: 0,
         language: 'und',
+        disabledUntilTime: 0,
         primary: true,
         audio: type == 'audio' ? streamInfo.stream : null,
         video: type == 'video' ? streamInfo.stream : null,
@@ -1926,6 +1927,11 @@ shaka.hls.HlsParser = class {
         const pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
             absoluteMediaPlaylistUri, pUri);
 
+        let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
+        if (item.getAttributeValue('GAP') == 'YES') {
+          partialStatus = shaka.media.SegmentReference.Status.MISSING;
+        }
+
         const partial = new shaka.media.SegmentReference(
             pStartTime,
             pEndTime,
@@ -1935,7 +1941,12 @@ shaka.hls.HlsParser = class {
             initSegmentReference,
             /* timestampOffset= */ 0, // This value is ignored in sequence mode.
             /* appendWindowStart= */ 0,
-            /* appendWindowEnd= */ Infinity);
+            /* appendWindowEnd= */ Infinity,
+            /* partialReferences= */ [],
+            /* tilesLayout= */ '',
+            /* tileDuration= */ null,
+            /* syncTime= */ null,
+            partialStatus);
         partialSegmentRefs.push(partial);
       } // for-loop of hlsSegment.partialSegments
     }

package/lib/media/drm_engine.js

@@ -355,7 +355,8 @@ shaka.media.DrmEngine = class {
         shaka.media.DrmEngine.fillInDrmInfoDefaults_(
             info,
             shaka.util.MapUtils.asMap(this.config_.servers),
-            shaka.util.MapUtils.asMap(this.config_.advanced || {}));
+            shaka.util.MapUtils.asMap(this.config_.advanced || {}),
+            this.config_.keySystemsMapping);
       }
     }
 
@@ -2224,16 +2225,20 @@ shaka.media.DrmEngine = class {
    * that the parser left blank. Before working with any drmInfo, it should be
    * passed through here as it is uncommon for drmInfo to be complete when
    * fetched from a manifest because most manifest formats do not have the
-   * required information.
+   * required information. Also applies the key systems mapping.
    *
    * @param {shaka.extern.DrmInfo} drmInfo
    * @param {!Map.<string, string>} servers
    * @param {!Map.<string, shaka.extern.AdvancedDrmConfiguration>}
    *   advancedConfigs
+   * @param {!Object.<string, string>} keySystemsMapping
    * @private
    */
-  static fillInDrmInfoDefaults_(drmInfo, servers, advancedConfigs) {
-    if (!drmInfo.keySystem) {
+  static fillInDrmInfoDefaults_(drmInfo, servers, advancedConfigs,
+      keySystemsMapping) {
+    const originalKeySystem = drmInfo.keySystem;
+
+    if (!originalKeySystem) {
       // This is a placeholder from the manifest parser for an unrecognized key
       // system.  Skip this entry, to avoid logging nonsensical errors.
       return;
@@ -2254,14 +2259,14 @@ shaka.media.DrmEngine = class {
     // The only way to get license servers from the manifest is not to specify
     // any in your player config.
 
-    if (drmInfo.keySystem == 'org.w3.clearkey' && drmInfo.licenseServerUri) {
+    if (originalKeySystem == 'org.w3.clearkey' && drmInfo.licenseServerUri) {
       // Preference 1: Clear Key with pre-configured keys will have a data URI
       // assigned as its license server.  Don't change anything.
       return;
     } else if (servers.size) {
       // Preference 2: If anything is configured at the application level,
       // override whatever was in the manifest.
-      const server = servers.get(drmInfo.keySystem) || '';
+      const server = servers.get(originalKeySystem) || '';
 
       drmInfo.licenseServerUri = server;
     } else {
@@ -2273,7 +2278,7 @@ shaka.media.DrmEngine = class {
       drmInfo.keyIds = new Set();
     }
 
-    const advancedConfig = advancedConfigs.get(drmInfo.keySystem);
+    const advancedConfig = advancedConfigs.get(originalKeySystem);
 
     if (advancedConfig) {
       if (!drmInfo.distinctiveIdentifierRequired) {
@@ -2307,6 +2312,10 @@ shaka.media.DrmEngine = class {
       }
     }
 
+    if (keySystemsMapping[originalKeySystem]) {
+      drmInfo.keySystem = keySystemsMapping[originalKeySystem];
+    }
+
     // Chromecast has a variant of PlayReady that uses a different key
     // system ID.  Since manifest parsers convert the standard PlayReady
     // UUID to the standard PlayReady key system ID, here we will switch
@@ -2315,7 +2324,7 @@ shaka.media.DrmEngine = class {
     // player config uses the standard PlayReady ID for license server
     // configuration.
     if (window.cast && window.cast.__platform__) {
-      if (drmInfo.keySystem == 'com.microsoft.playready') {
+      if (originalKeySystem == 'com.microsoft.playready') {
         drmInfo.keySystem = 'com.chromecast.playready';
       }
     }

package/lib/media/gap_jumping_controller.js

@@ -11,6 +11,7 @@ goog.require('shaka.media.PresentationTimeline');
 goog.require('shaka.media.StallDetector');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.util.EventManager');
+goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
 
@@ -32,8 +33,13 @@ shaka.media.GapJumpingController = class {
    *   playable region. The gap jumping controller takes ownership over the
    *   stall detector.
    *   If no stall detection logic is desired, |null| may be provided.
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    */
-  constructor(video, timeline, config, stallDetector) {
+  constructor(video, timeline, config, stallDetector, onEvent) {
+    /** @private {?function(!Event)} */
+    this.onEvent_ = onEvent;
+
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
@@ -52,6 +58,9 @@ shaka.media.GapJumpingController = class {
     /** @private {number} */
     this.prevReadyState_ = video.readyState;
 
+    /** @private {number} */
+    this.gapsJumped_ = 0;
+
     /**
      * The stall detector tries to keep the playhead moving forward. It is
      * managed by the gap-jumping controller to avoid conflicts. On some
@@ -98,6 +107,7 @@ shaka.media.GapJumpingController = class {
       this.stallDetector_ = null;
     }
 
+    this.onEvent_ = null;
     this.timeline_ = null;
     this.video_ = null;
   }
@@ -121,6 +131,15 @@ shaka.media.GapJumpingController = class {
   }
 
 
+  /**
+   * Returns the total number of playback gaps jumped.
+   * @return {number}
+   */
+  getGapsJumped() {
+    return this.gapsJumped_;
+  }
+
+
   /**
    * Called on a recurring timer to check for gaps in the media.  This is also
    * called in a 'waiting' event.
@@ -209,6 +228,9 @@ shaka.media.GapJumpingController = class {
     }
 
     this.video_.currentTime = jumpTo;
+    this.gapsJumped_++;
+    this.onEvent_(
+        new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));
   }
 };
 

package/lib/media/playhead.js

@@ -41,6 +41,20 @@ shaka.media.Playhead = class {
    */
   setStartTime(startTime) {}
 
+  /**
+   * Get the number of playback stalls detected by the StallDetector.
+   *
+   * @return {number}
+   */
+  getStallsDetected() {}
+
+  /**
+   * Get the number of playback gaps jumped by the GapJumpingController.
+   *
+   * @return {number}
+   */
+  getGapsJumped() {}
+
   /**
    * Get the current playhead position. The position will be restricted to valid
    * time ranges.
@@ -133,6 +147,16 @@ shaka.media.SrcEqualsPlayhead = class {
     return time || 0;
   }
 
+  /** @override */
+  getStallsDetected() {
+    return 0;
+  }
+
+  /** @override */
+  getGapsJumped() {
+    return 0;
+  }
+
   /** @override */
   notifyOfBufferingChange() {}
 };
@@ -160,8 +184,10 @@ shaka.media.MediaSourcePlayhead = class {
    * @param {function()} onSeek
    *     Called when the user agent seeks to a time within the presentation
    *     timeline.
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    */
-  constructor(mediaElement, manifest, config, startTime, onSeek) {
+  constructor(mediaElement, manifest, config, startTime, onSeek, onEvent) {
     /**
      * The seek range must be at least this number of seconds long. If it is
      * smaller than this, change it to be this big so we don't repeatedly seek
@@ -192,12 +218,17 @@ shaka.media.MediaSourcePlayhead = class {
     /** @private {?number} */
     this.lastCorrectiveSeek_ = null;
 
+    /** @private {shaka.media.StallDetector} */
+    this.stallDetector_ =
+        this.createStallDetector_(mediaElement, config, onEvent);
+
     /** @private {shaka.media.GapJumpingController} */
     this.gapController_ = new shaka.media.GapJumpingController(
         mediaElement,
         manifest.presentationTimeline,
         config,
-        this.createStallDetector_(mediaElement, config));
+        this.stallDetector_,
+        onEvent);
 
     /** @private {shaka.media.VideoWrapper} */
     this.videoWrapper_ = new shaka.media.VideoWrapper(
@@ -261,6 +292,16 @@ shaka.media.MediaSourcePlayhead = class {
     return time;
   }
 
+  /** @override */
+  getStallsDetected() {
+    return this.stallDetector_.getStallsDetected();
+  }
+
+  /** @override */
+  getGapsJumped() {
+    return this.gapController_.getGapsJumped();
+  }
+
   /**
    * Gets the playhead's initial position in seconds.
    *
@@ -475,10 +516,12 @@ shaka.media.MediaSourcePlayhead = class {
    *
    * @param {!HTMLMediaElement} mediaElement
    * @param {shaka.extern.StreamingConfiguration} config
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    * @return {shaka.media.StallDetector}
    * @private
    */
-  createStallDetector_(mediaElement, config) {
+  createStallDetector_(mediaElement, config, onEvent) {
     if (!config.stallEnabled) {
       return null;
     }
@@ -492,7 +535,7 @@ shaka.media.MediaSourcePlayhead = class {
     // playhead forward.
     const detector = new shaka.media.StallDetector(
         new shaka.media.StallDetector.MediaElementImplementation(mediaElement),
-        threshold);
+        threshold, onEvent);
 
     detector.onStall((at, duration) => {
       shaka.log.debug(`Stall detected at ${at} for ${duration} seconds.`);