rx-player 3.29.0-dev.2022091600 → 4.0.0-alpha.2022100600

package/CHANGELOG.md

@@ -1,28 +1,95 @@
 # Changelog
 
-## v3.29.0-dev.2022091600 (2022-09-16)
+## v4.0.0-alpha.2022100600 (2022-10-06)
 
-### Features
-
-  - add `networkConfig.segmentRequestTimeout` and `networkConfig.manifestRequestTimeout` options to loadVideo to configure the timeout of respectively segment and manifest requests [#1156]
-  - add `timeout` property to the first argument communicated to a `segmentLoader` (from `loadVideo`'s `transportOptions`) [#1156]
-  - add `timeout` property to a new third argument communicated to a `manifestLoader` (from `loadVideo`'s `transportOptions`) [#1156]
-  - add `keySystems[].onKeyExpiration` to `loadVideo` options to configure the behavior the RxPlayer should have on key expiration [#1157]
-  - add `keyStatuses` property to an `EncryptedMediaError` with the `KEY_STATUS_CHANGE_ERROR` code to communicate which key id and key statuses caused issues. [#1157]
-
-### Bug fixes
+### Changed
 
-  - Compat/Directfile: Fix an issue with LG TV when playing multiple directfile contents with the `stopAtEnd` player option set to `true` [#1154]
-  - Compat: To work around an issue on LG TVs, also specify a request timeout manually through a `setTimeout` call when XMLHttpRequests are created for Manifest and segment requests [#1152]
-  - Compat: Fix issue with Samsung TVs where starting playback on a discontinuity could lead to infinite rebuffering [#1140]
-  - Compat: For `"directfile"` contents, also consider `AudioTrack` with a `description` (without an "s") as audio-description audio tracks to work-around what seems to be a Safari typo [#1160]
-  - Better handle valid reverse playback use cases by not skipping gaps when the playback rate has been set to `0` or a negative value [#1138]
-  - DRM: When using persistent licenses, create new MediaKeySession when `load` resolves with `false`, instead of relying the same, to fix issues with such persistent sessions [#1139]
+  - Create `"FREEZING"` player state for cases where the playback position is currently not advancing due to an unknown reason, to separate it from regular `"BUFFERING"`. [#1146]
+  - The `RELOADING` player state (gettable  through the `getPlayerState` and `playerStateChange` API) can now happen at any time to unlock playback.
+  - Remove bitrate API: `getAvailableVideoBitrates`, `getAvailableAudioBitrates`, `setAudioBitrate`, `setVideoBitrate`, `getAudioBitrate`, `getVideoBitrate` in profit of the Representations lock APIs [#1144]
+  - Remove track preferences API (methods: `getPreferredAudioTracks`, `getPreferredVideoTracks`, `setPreferredAudioTracks` and `setPreferredVideoTracks`, types: `IAudioTrackPreference`, `ITextTrackPreference` and `IVideoTrackPreference`) in profit of the new tracks API
+  - Remove `getManualVideoBitrate` and `getManualAudioBitrate` in profit of the new Representations lock APIs
+  - Replace `initialAudioBitrate` and `initialVideoBitrate` constructor options with a single `baseBandwidth` option, which better translates what this option is actually doing and allows for future optimizations on our side. [#1155]
+  - Rename `audioTrackSwitchingMode` loadVideo option into `defaultAudioTrackSwitchingMode` [#1030]
+  - Remove `manualBitrateSwitchingMode` loadVideo option to instead rely on the `switchingMode` property of each `lockVideoRepresentations` and `lockAudioRepresentations` calls. [#1030]
+  - Remove `audioBitrateChange` and `videoBitrateChange` API in profit of the new `audioRepresentationChange` and `videoRepresentationChange` events
+  - Remove `availableAudioBitratesChange` and `availableVideoBitratesChange` events. Those are less needed with the new Representations lock API and can be mostly replicated through the `audioTrackChange` and `videoTrackChange` events
+  - "Flatten" the `transportOptions` loadVideo options by putting all its inner properties directly at the top level of loadVideo options, to simplify its documentation and discoverability [#1149]
+  - Rename `networkConfig` into `requestConfig` and re-organize its inner properties to pave the way for future request-related APIs.
+  - Remove `stopAtEnd` `loadVideo` option and don't automatically stop when reaching the end by default. This behavior can be counter-intuitive and can be very easily implemented by the application.
+  - Remove `decipherabilityUpdate` event as it appeared to be not easily exploitable and exposed internal logic too much [#1168]
+  - Remove `getUrl` method in profit of the more powerful `getContentUrls`
+  - Remove methods: `getManifest`, `getCurrentAdaptations` and `getCurrentRepresentations`, as they reveal the RxPlayer's internals too much
+  - The `"smooth"` transport now needs to be communicated the URL of the Manifest directly (previously, it was possible to redirect it to a XML or JSON file first due to Canal+ legacy reasons).
+  - Remove the `supplementaryTextTracks` loadVideo option. You can use the `TextTrackRenderer` tool if you wish to diplay external subtitles on top of your content.
+  - Rename `maximumBufferTime` in `positionUpdate` events to `maximumPosition`
+  - Remove `getVideoPlayedTime` and `getVideoLoadedTime` methods. Their names was very confusing and can be re-implemented relatively easily using the media element's buffered property.
+  - Rename `getVideoDuration` to `getMediaDuration`, to avoid confusion with the video track's duration.
+  - Rename `getVideoBufferGap` to `getCurrentBufferGap, to avoid confusion with the "buffer gap" specific to the video track.
+  - Remove image-related API: `supplementaryImageTracks` `loadVideo` option, `imageTrackUpdate` event, `getImageTrackData` method. Those are better handled by an application. The `parseBifThumbnails` tool is still available.
+  - Replace `keySystems[].licenseStorage` `keySystems` option (for a `loadVideo` call) by the better-named `persistentLicenseConfig`. The `persistentLicense` boolean (also a `keySystems` option) has also been removed because it was redundant with it) [#1147]
+  - Remove `persistentStateRequired` API, in profit of the more powerful `persistentState` API [#1148]
+  - Remove `distinctiveIdentifierRequired` API, in profit of the more powerful `distinctiveIdentifier` API [#1148]
+  - Remove `keySystems[].onKeyStatusesChange` API as it seems to never be used [#1148]
+  - Remove `aggressiveMode` from the `transportOptions` `loadVideo` option
+  - Remove deprecated `throttleWhenHidden` player option in profit of `throttleVideoBitrateWhenHidden`
+  - Change payload of `periodChange` events, so they emit only core properties related to a `Period`.
+  - Change arguments given to a `transportOptions.segmentLoader` function (the `loadVideo` option): it now doesn't give the full `Manifest`, `Period`, `Adaptation`, `Representation` and `ISegment` structures in arguments but only core properties from it [#995]
+  - Custom `manifestLoader` function added to what was previously the `loadVideo`'s `transportOptions` option now set an object as argument (with an `url`property), to let us bring improvements on it in the future [#995]
+  - A Representation's `frameRate` is now always a number - in terms of frame per seconds - instead of a string.
+  - `Representations` (in methods: `getAvailableVideoTracks`, `getVideoTrack`, `representationFilter`, `getAvailableAudioTracks`, `getAudioTrack` and events: `audioTrackChange` and `videoTrackChange`) can have an `undefined` bitrate
+  - Remove deprecated fullscreen related APIs (methods: `isFullscreen`, `setFullscreen`, `exitFullscreen`, event: `fullscreenChange`) as a a UI is much more adapted to that task and can also bring with it things like a progress bar or HTML text tracks
+  - Remove deprecated `getNativeTextTrack` method. If advanced features are wanted, it's better to just use the HTML text track API
+  - Remove deprecated `nativeTextTracksChange` event. Same reason than for `getNativeTextTrack`
+  - Remove deprecated `hideNativeSubtitles` from `loadVideo` options. Same reason than for `getNativeTextTrack`
+  - Remove `xhr` property from a `NetworkError`. Doing so stop us from using the fetch API
+  - Remove deprecated `defaultAudioTrack` and `defaultTextTrack`in profit of new track APIs
+  - Remove `bitrateEstimationChange` event as it is poorly understood (it's not always close to the expected bandwidth) and has a very complex relationship with the chosen quality.
+  - Remove the notion of environment variables linked to personalized builds (e.g. RXP_DASH) in profit of the minimal RxPlayer.
+  - Rename `IPersistentSessionStorage` type to `IPersistentLicenseConfig` [#1147]
+  - Remove undocumented `audioRobustnesses` and `videoRobustnesses` properties of the `keySystems` option of `loadVideo` calls, as more powerful solutions now exist: respectively `audioCapabilitiesConfig` and `videoCapabilitiesConfig` [#1148]
+  - Remove public types `ISupplementaryTextTrackOption` and `ISupplementaryImageTrackOption`. Those are the types respectively for `supplementaryTextTracks` and `supplementaryImageTracks` which have been removed
+  - Remove public types `IBitrateEstimate` as no API depend on it anymore.
+  - Remove public types `IManifest`, `IPeriod`, `IAdaptation`, `IRepresentation`, `IRepresentationInfos`, `IBifThumbnail`, `IBifObject` and `IExposedSegment` as no API depend on them anymore.
+  - Remove public types `IDefaultAudioTrackOption` and `IDefaultTextTrackOption`. Those are the types respectively for `defaultAudioTrack` and `defaultTextTrack` `loadVideo` options which have been removed
 
-### Other improvements
+### Features
 
-  - In the experimental "local" transport, add `incomingRanges` property to signal the time ranges of remaining data, allowing better discontinuity handling and duration estimates for sill-loading dowloaded contents [#1151]
-  - Only send through `"warning"` events, just one `EncryptedMediaError` with a `KEY_STATUS_CHANGE_ERROR` code when multiple ones arises at the same time [#1157]
+  - `setAudioTrack`, `setVideoTrack` and `setTextTrack` now may take an object in argument, with the track's id set as a `trackId` property, to allow new features
+  - Add `switchingMode` optional property to `setVideoTrack` and `setAudioTrack`, to configure the way in which the RxPlayer switches between the previous and new track
+  - Add optional `periodId` property to `setAudioTrack`, `setVideoTrack` and `setTextTrack`, to allow setting the track of another, future or past, Period.
+  - `getAvailableAudioTracks`, `getAvailableTextTracks`, `getAvailableVideoTracks`, `getAudioTrack`, `getTextTrack` and `getVideoTrack` can now optionally take a `periodId` argument to retrieve track information on a specific Period, different than the current one.
+  - `disableTextTrack`, and`disableVideoTrack` can now optionally take a `periodId` argument to disable a track for a specific Period
+  - Add optional `lockedRepresentations` property to  `setAudioTrack` and `setVideoTrack`, to only filter some allowed Representations (i.e. qualities) after switching to the wanted track.
+  - Add `getCurrentPeriod` method to retrieve information on the Period currently played
+  - Add `getAvailablePeriods` method to retrieve information on all Periods on which a track or Representation choice can be made
+  - Add `lockVideoRepresentations`, `lockAudioRepresentations`, `getLockedVideoRepresentations`, `getLockedAudioRepresentations`, `unlockVideoRepresentations` and `unlockAudioRepresentations` methods to allow a complex selection of Representations that are currently allowed to play.
+  - Add `getVideoRepresentation` and `getAudioRepresentation` method to retrieve information on the currently loaded representations [#1144]
+  - Add `audioRepresentationChange` and `videoRepresentationChange` events to be notified when the currently-loaded Representation for the current Period changes.
+  - Add `getContentUrls` allowing to retrieve the one or several known URLs through which the current Manifest or content is reachable.
+  - Add `newAvailablePeriods` event to signal new Period on which a track and/or Representation choice can be made
+  - Add `brokenRepresentationsLock` event for when a Representations lock could not be respected anymore
+  - Add `autoTrackSwitch` event for when a chosen track could not be kept by the RxPlayer
+  - Add  `distinctiveIdentifier` property in the `keySystems` option (given to the `loadVideo` method) to have full control over the MediaKeySystemConfiguration of the same name in the chosen key system [#1148]
+  - Add  `persistentState`  property in the `keySystems` option (given to the `loadVideo` method) to have full control over the MediaKeySystemConfiguration of the same name in the chosen key system [#1148]
+  - Add `audioCapabilitiesConfig` and `videoCapabilitiesConfig` properties in the `keySystems` option (given to the `loadVideo` method)  to allow advanced configuration of respectively the "audioCapabilities" and "videoCapabilities" in the asked MediaKeySystemConfiguration [#1148]
+  - Add `ISegmentLoaderContext` public type for the first argument of the `segmentLoader` API
+  - Add `IRepresentationFilterRepresentation` public type for the first argument of the `representationFilter` API
+  - Add `IRepresentationContext` public type for the second argument of the `representationFilter` API
+  - Add `IManifestLoaderInfo` public type for the first argument of the `manifestLoader` API
+  - Add `IDecipherabilityUpdatePeriodInfo` public type to define the `periodInfo` property of a `decipherabilityUpdate` event
+  - Add `IPeriodChangeEvent` public type to define the properties send through a `periodChange` event
+  - Add `IPeriod` public type to define a Period object returned by methods like `getAvailablePeriods` or `getCurrentPeriod`
+  - Add `IVideoTrackSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `setAudioTrack`
+  - Add `IAudioRepresentationsSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `lockAudioRepresentations`
+  - Add `IVideoRepresentationsSwitchingMode` public type to define the type of the `switchingMode` property optionally given to `lockAudioRepresentations`
+  - Add `IBrokenRepresentationsLockContext` public type to define the type sent as a payload of the `brokenRepresentationsLock` event
+  - Add `IAutoTrackSwitchEventPayload` public type to define the type sent as a payload of the `autoTrackSwitch` event
+  - Add `ILockedVideoRepresentationsSettings` public type to define the object that should be given to the new `lockVideoRepresentation` method
+  - Add `ILockedAudioRepresentationsSettings` public type to define the object that should be given to the new `lockAudioRepresentation` method
+  - Add `IAudioTrackSetting` public type to define the object that may be given to the `setAudioTrack` method
+  - Add `IVideoTrackSetting` public type to define the object that may be given to the `setVideoTrack` method
+  - Add `ITextTrackSetting` public type to define the object that may be given to the `setTextTrack` method
 
 ## v3.28.0 (2022-07-12)
 

package/FILES.md

@@ -167,7 +167,6 @@ What is exported there are functions to load:
   - Manifests/MPDs
   - video/audio segments
   - subtitles tracks
-  - image tracks
 
 For different streaming technologies.
 

package/MAINTAINERS.md

@@ -16,7 +16,6 @@ RxPlayer-related question or to propose new features.
 Here is the list of current maintainers:
 
 - Paul Berberian <paul.berberian@canal-plus.com>
-- Paul Rosset <paul.rosset@canal-plus.com>
 
 
 ## Previous maintainers ########################################################
@@ -24,8 +23,10 @@ Here is the list of current maintainers:
 Here is the list of previous maintainers, which are not working on the project
 anymore:
 
+- Achraf Laamoum <achraf.laamoum@canal-plus.com>
 - Alexandre Duros <alexandre.duros@canal-plus.com>
 - Antoine Maillard <antoine.maillard@canal-plus.com>
 - Guillaume Bentaieb <guillaume.bentaieb@canal-plus.com>
 - Guillaume Renault <guillaume.renault@canal-plus.com>
+- Paul Rosset <paul.rosset@canal-plus.com>
 - Pierre Guilleminot <pierre.guilleminot@canal-plus.com>

package/VERSION

@@ -1 +1 @@
-3.29.0-dev.2022091600
+4.0.0-alpha.2022100600

package/a.js

@@ -0,0 +1,373 @@
+// Cas les plus fréquents
+
+// Seulement mettre la piste courante en français
+// ----------------------------------------------
+//
+// Rien ne change:
+
+const choosenTrack = player.getAvailableAudioTracks()
+  .find((t) => t.normalized === "fra" && t.audioDescription !== true);
+if (choosenTrack !== undefined) {
+  player.setAudioTrack(choosenTrack.id);
+}
+
+// Mettre la piste francaise pour toutes les Periods
+// -------------------------------------------------
+//
+// Brancher l'event `"newAvailablePeriods"` pour les futures Periods anoncées
+// après mise à jour du Manifest et au changement de contenu et appeller
+// `setAudioTrack` pour toutes les Periods:
+
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach(setFrenchTrackForPeriod);
+});
+player.getAvailablePeriods()
+  .forEach(setFrenchTrackForPeriod);
+
+function setFrenchTrackForPeriod(periodInfo) {
+  const chosenTrack = player.getAvailableAudioTracks(periodInfo.id)
+    .find((t) => t.normalized === "fra" && t.audioDescription !== true);
+  if (choosenTrack !== undefined) {
+    player.setAudioTrack( { periodId: periodInfo.id,
+                            trackId: chosenTrack.id });
+  }
+}
+
+// Plus général: changer la piste pour toutes les Periods
+// ------------------------------------------------------
+//
+// Pareil, juste ajoutons un store simplifié:
+
+const SomeStore = {
+  language: "eng",
+  isAudioDescription: false,
+};
+
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach(setAudioTrackForPeriod);
+});
+
+function updateAllAudioTracks(newLanguage, newAudioDescriptionStatus) {
+  SomeStore.language = newLanguage;
+  SomeStore.isAudioDescription = newAudioDescriptionStatus;
+  player.getAvailablePeriods().forEach(setAudioTrackForPeriod);
+}
+
+function setAudioTrackForPeriod(periodInfo) {
+  const { language, isAudioDescription } = SomeStore;
+  const choosenTrack = player.getAvailableAudioTracks(periodInfo.id)
+    .find((t) =>
+      t.normalized === language &&
+      isAudioDescription ? t.audioDescription === true :
+                           t.audioDescription !== true);
+  if (choosenTrack !== undefined) {
+    player.setAudioTrack({
+      trackId: choosenTrack.id,
+      lockedRepresentations: [chosenTrack.representations[0].id]
+    }, periodInfo.id);
+  }
+}
+
+
+// Simplifier et optimiser ce cas fréquent pour le futur ?
+// -------------------------------------------------------
+//
+// Proposition d'un "defaultAudioTrackSelector" configurable pour définir la piste par
+// défaut:
+
+const SomeStore = {
+  language: "eng",
+  isAudioDescription: false,
+};
+
+function updateAllAudioTracks(newLanguage, newAudioDescriptionStatus) {
+  SomeStore.language = newLanguage;
+  SomeStore.isAudioDescription = newAudioDescriptionStatus;
+  player.setDefaultAudioTrackSelector(setAudioTrackForPeriod);
+}
+
+function setAudioTrackForPeriod(audioTracks, _periodInfo) {
+  const { language, isAudioDescription } = SomeStore;
+  const choosenTrack = audioTracks.find((t) =>
+      t.normalized === language &&
+      isAudioDescription ? t.audioDescription === true :
+                           t.audioDescription !== true);
+  if (choosenTrack === undefined) {
+    // preference not found, let the RxPlayer choose for us
+    return undefined;
+  }
+  // preference found: select it
+  return choosenTrack.id;
+}
+
+// => reset pour la Period courante ? second argument booléen
+// => persisté au changement de contenu ? oui
+// => autoriser un setAudioTrack pendant qu'un defaultAudioTrackSelector est actif ? oui
+
+player.hasDefaultAudioTrackSelector();
+player.removeDefaultAudioTrackSelector();
+
+
+// All APIs:
+
+player.getAvailableAudioTracks();
+player.getAvailableVideoTracks();
+player.getAvailableTextTracks();
+player.getAudioTrack();
+player.getVideoTrack();
+player.getTextTrack();
+player.setAudioTrack();
+player.setVideoTrack();
+player.setTextTrack();
+
+player.setDefaultAudioTrackSelector();
+player.setDefaultVideoTrackSelector();
+player.setDefaultTextTrackSelector();
+player.removeDefaultAudioTrackSelector();
+player.removeDefaultVideoTrackSelector();
+player.removeDefaultTextTrackSelector();
+player.hasDefaultAudioTrackSelector();
+player.hasDefaultVideoTrackSelector();
+player.hasDefaultTextTrackSelector();
+
+
+// ```
+// # Representation (quality) selection
+//
+// ## lockVideoRepresentations / lockAudioRepresentations
+
+
+player.setMaxVideoBitrate(1000);
+
+// For all future Periods and contents
+player.addEventListener("newAvailablePeriods", (periods) => {
+  periods.forEach((p) => limitVideoBitrate(p, 1000));
+});
+
+// If currently playing, for all Periods in the current content
+player.getAvailablePeriods()
+  .forEach((p) => limitVideoBitrate(p, 1000));
+
+// At each track change
+player.setAudioTrack({
+  trackId,
+  periodId,
+  lockedRepresentations: getLimited(p, 1000),
+});
+
+
+// Automatically filter which Representation will be played by default
+player.setAutoVideoRepresentationsLocker((videoTrack, _periodInfo) => {
+  const filtered = videoTrack.representations
+    .filter(rep => rep.bitrate !== undefined && rep.bitrate <= 1000)
+    .map(rep => rep.id);
+
+  if (filtered.length === 0) {
+    if (videoTrack.representations.length === 0) {
+      return;
+    }
+    const minBitrate = videoTrack.representations.sort((a, b) => {
+
+    });
+  }
+}, true);
+
+player.setDefaultVideoTrackSelector((videoTracks, _periodInfo) => {
+  const activeVideoTrack = videoTracks.find(v => v.active) ?? videoTracks[0];
+  const filtered = activeVideoTrack.representations
+    .filter(rep => rep.bitrate !== undefined && rep.bitrate <= 1000)
+    .map(rep => rep.id);
+
+  if (filtered.length === 0) {
+    if (activeVideoTrack.representations.length === 0) {
+      return;
+    }
+    const minBitrate = activeVideoTrack.representations.sort((a, b) => {
+
+    });
+  }
+}, true);
+
+// Powerful enough to remove the need of track preference APIs, bitrate APIs and the
+// representationFilter API which all have their issues (mostly, they are not flexible enough and had
+// some complex behavior when diving into the details).
+//
+// However simple use cases that were previously easy to configure through those APIs are much harder
+// with thhe new.
+
+
+// representationFilter
+//
+// If this function was used to filter out some audio and/or video
+// Representation (which is all cases we've seen), its behavior can be
+// reproduced by using the new Representations "locking" feature, which allows
+// to only allow some Representations from being played (see
+// `lockVideoRepresentations` / `lockAudioRepresentations`).
+//
+// The new Representations locking feature is also more powerful, allowing to
+// inspect all other Representations from the corresponding track - or even all
+// other tracks while the filter function is called.
+//
+// The easiest way of replacing `representationFilter` could be by locking
+// wanted Representations through a "default video/audio track selector" before
+// calling `loadVideo`.
+// This can be donethrough the `setDefaultVideoTrackSelector` and/or the
+// `setDefaultAudioTrackSelector` method, depending on if you want to limit the
+// video Representations or the audio Representations. The following examples
+// are going to show how this can be done for video tracks, but it can also be
+// applied on audio tracks with the corresponding alternative methods.
+
+// Only authorize some video Representations from being played on the default
+// video tracks chosen by the RxPlayer:
+player.setDefaultVideoTrackSelector((videoTracks, periodInfo) => {
+  // Note: The `videoTracks` array begins by the default video track
+  const filtered = videoTracks[0].representations.filter(representationFilter);
+  return {
+    periodId: periodInfo.id,
+    lockedRepresentations: filtered,
+    trackId: videoTracks[0].id,
+  };
+});
+
+// Note that this filter is persisted even through the next contents you will
+// play. If you want to remove it, you can call the
+// `removeDefaultVideoTrackSelector` method:
+player.removeDefaultVideoTrackSelector();
+
+// If switching the video track is possible in your application, don't forget to
+// also apply the filter there:
+function changeVideoTrack(periodId, videoTrack) {
+  const filtered = videoTrack.representations.filter(representationFilter);
+  player.setVideoTrack({
+    periodId,
+    lockedRepresentations: filtered,
+    trackId: videoTrack.id,
+  });
+}
+
+// And that's all! You should now always be filtering out video Representations
+// for all video tracks chosen.
+
+// Note that if you display Representations choice to the user in some ways, you
+// might also want to remove the choice from that list:
+function getAvailableVideoRepresentations() {
+  player.getVideoTrack()
+  if (videoTrack === null) {
+    return []; //"No video track currently");
+  }
+  return videoTrack.representations.filter(representationFilter);
+}
+
+// update the documentation:
+//   - setAudioTrack
+//   - setTextTrack
+//   - setVideoTrack
+//
+// Add the documentation:
+//   - getAvailablePeriods method
+//
+// Write tests
+//
+// representationChange event?
+
+// /!\ ChromeCast etc.
+// singleLicensePer: "periods"
+
+// test Samsung
+
+
+// Example: Know when the video Representations lock is enabled / disabled for
+// the Period currently being played
+
+let areVideoRepresentationsLocked = false;
+
+function updateAreVideoRepresentationsLocked() {
+ areVideoRepresentationsLocked =
+   rxPlayer.getLockedVideoRepresentations() !== null;
+}
+
+// Update it each time the video lock for the current Period is "broken"
+rxPlayer.addEventListener("brokenRepresentationsLock", (info) => {
+  const currentPeriod = rxPlayer.getCurrentPeriod();
+  if (
+    info.trackType === "video" &&
+    currentPeriod !== null && info.period.id === currentPeriod.id
+  ) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// Update it each time the video track for the current Period changes, whether
+// it was done explicitely (through setVideoTrack/disableVideoTrack),
+// implicitely (the RxPlayer automatically switched by itself) or just because
+// a new Period is now being played.
+rxPlayer.addEventListener("videoTrackChange", () => {
+  updateAreVideoRepresentationsLocked();
+});
+
+// And update it each time the lock API are called for the current Period
+function lockVideoRepresentations(reps) {
+ rxPlayer.lockVideoRepresentations(reps);
+ updateAreVideoRepresentationsLocked();
+}
+function unlockVideoRepresentations() {
+ rxPlayer.unlockVideoRepresentations();
+ updateAreVideoRepresentationsLocked();
+}
+
+
+// Example: Know when the video Representations lock is enabled / disabled for
+// any Period
+
+// First let's consider a given period `id` named `PERIOD_ID`
+const PERIOD_ID = "<SOME_PERIOD_ID>";
+
+let areVideoRepresentationsLockedForPeriod = false;
+
+function updateAreVideoRepresentationsLocked() {
+ areVideoRepresentationsLockedForPeriod =
+   rxPlayer.getLockedVideoRepresentations(PERIOD_ID) !== null;
+}
+
+// Update it each time the video lock for the corresponding Period is "broken"
+rxPlayer.addEventListener("brokenRepresentationsLock", (info) => {
+  if (info.trackType === "video" && info.period.id === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// Update it each time the video track is voluntarly changed/disabled for that Period
+function setVideoTrackForPeriod(periodId, trackId) {
+  rxPlayer.setVideoTrack({ periodId, trackId });
+  if (periodId === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+}
+function disableVideoTrackForPeriod() {
+  rxPlayer.setVideoTrack({ periodId, trackId });
+  if (periodId === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+}
+
+// Update it each time, the RxPlayer decides to automatically change the video
+// track for that Period (extremely rare)
+rxPlayer.addEventListener("autoTrackSwitch", (info) => {
+  if (info.trackType === "video" && info.period.id === PERIOD_ID) {
+    updateAreVideoRepresentationsLocked();
+  }
+});
+
+// And update it each time the lock API are called for that Period
+function lockVideoRepresentations(periodId, representations) {
+ rxPlayer.lockVideoRepresentations({ periodId, representations });
+ if (periodId === PERIOD_ID) {
+  updateAreVideoRepresentationsLocked();
+ }
+}
+function unlockVideoRepresentations(periodId) {
+ rxPlayer.unlockVideoRepresentations(periodId);
+ if (periodId === PERIOD_ID) {
+  updateAreVideoRepresentationsLocked();
+ }
+}

package/dist/_esm5.processed/compat/add_text_track.d.ts

@@ -23,11 +23,9 @@ import { ICompatTextTrack } from "./browser_compatibility_types";
  *     undefined if no trackElement was added.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Boolean} hidden - If `true`, the text track will be hidden by
- * default. If `false`, the text track will be directly showing.
  * @returns {Object}
  */
-export default function addTextTrack(mediaElement: HTMLMediaElement, hidden: boolean): {
+export default function addTextTrack(mediaElement: HTMLMediaElement): {
     track: ICompatTextTrack;
     trackElement: HTMLTrackElement | undefined;
 };

package/dist/_esm5.processed/compat/add_text_track.js

@@ -23,12 +23,10 @@ import { isIEOrEdge } from "./browser_detection";
  *     undefined if no trackElement was added.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Boolean} hidden - If `true`, the text track will be hidden by
- * default. If `false`, the text track will be directly showing.
  * @returns {Object}
  */
-export default function addTextTrack(mediaElement, hidden) {
-    var _a, _b;
+export default function addTextTrack(mediaElement) {
+    var _a;
     var track;
     var trackElement;
     var kind = "subtitles";
@@ -36,15 +34,14 @@ export default function addTextTrack(mediaElement, hidden) {
         var tracksLength = mediaElement.textTracks.length;
         track = (tracksLength > 0 ? mediaElement.textTracks[tracksLength - 1] :
             mediaElement.addTextTrack(kind));
-        track.mode = hidden ? ((_a = track.HIDDEN) !== null && _a !== void 0 ? _a : "hidden") :
-            ((_b = track.SHOWING) !== null && _b !== void 0 ? _b : "showing");
+        track.mode = (_a = track.SHOWING) !== null && _a !== void 0 ? _a : "showing";
     }
     else {
         trackElement = document.createElement("track");
         mediaElement.appendChild(trackElement);
         track = trackElement.track;
         trackElement.kind = kind;
-        track.mode = hidden ? "hidden" : "showing";
+        track.mode = "showing";
     }
     return { track: track, trackElement: trackElement };
 }

package/dist/_esm5.processed/compat/browser_compatibility_types.d.ts

@@ -52,15 +52,8 @@ interface ICompatTextTrack extends TextTrack {
  * functions for some "old" browsers.
  */
 interface ICompatDocument extends Document {
-    fullscreenElement: Element | null;
-    mozCancelFullScreen?: () => void;
-    mozFullScreenElement?: HTMLElement;
     mozHidden?: boolean;
-    msExitFullscreen?: () => void;
-    msFullscreenElement?: Element | null;
     msHidden?: boolean;
-    webkitExitFullscreen: () => void;
-    webkitFullscreenElement: Element | null;
     webkitHidden?: boolean;
 }
 /**

package/dist/_esm5.processed/compat/event_listeners.d.ts

@@ -27,15 +27,6 @@ export interface IEventEmitterLike {
     removeEventListener: (eventName: string, handler: () => void) => void;
 }
 export declare type IEventTargetLike = HTMLElement | IEventEmitterLike | IEventEmitter<unknown>;
-/**
- * Returns a reference:
- *   - Set to `true` when the current page is considered visible and active.
- *   - Set to `false` otherwise.
- * @param {Object} stopListening - `CancellationSignal` allowing to free the
- * resources allocated to update this value.
- * @returns {Object}
- */
-declare function getPageActivityRef(stopListening: CancellationSignal): IReadOnlySharedReference<boolean>;
 export interface IPictureInPictureEvent {
     isEnabled: boolean;
     pipWindow: ICompatPictureInPictureWindow | null;
@@ -92,11 +83,6 @@ declare const onEnded$: (element: IEventTargetLike) => Observable<Event>;
  * @returns {Observable}
  */
 declare const onTimeUpdate$: (element: IEventTargetLike) => Observable<Event>;
-/**
- * @param {HTMLElement} element
- * @returns {Observable}
- */
-declare const onFullscreenChange$: (element: IEventTargetLike) => Observable<Event>;
 /**
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
@@ -178,4 +164,4 @@ declare const onEnded: (element: IEventTargetLike, listener: (event?: unknown) =
  * emits
  */
 declare function addEventListener(elt: IEventEmitterLike, evt: string, listener: (x?: unknown) => void, stopListening: CancellationSignal): void;
-export { addEventListener, getPageActivityRef, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onFullscreenChange$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };
+export { addEventListener, getPictureOnPictureStateRef, getVideoVisibilityRef, getVideoWidthRef, onEncrypted$, onEnded, onEnded$, onKeyAdded$, onKeyError$, onKeyMessage$, onKeyStatusesChange$, onLoadedMetadata$, onRemoveSourceBuffers$, onSeeked, onSeeked$, onSeeking, onSeeking$, onSourceClose$, onSourceEnded$, onSourceOpen$, onTextTrackChanges$, onTimeUpdate$, onUpdate$, };