rx-player 3.33.0 → 3.33.1

package/src/core/init/utils/initial_seek_and_play.ts

@@ -1,237 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { shouldValidateMetadata } from "../../../compat";
-import { READY_STATES } from "../../../compat/browser_compatibility_types";
-import { isSafariMobile } from "../../../compat/browser_detection";
-/* eslint-disable-next-line max-len */
-import shouldPreventSeekingAt0Initially from "../../../compat/should_prevent_seeking_at_0_initially";
-import { MediaError } from "../../../errors";
-import log from "../../../log";
-import { IPlayerError } from "../../../public_types";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../../../utils/reference";
-import { CancellationError, CancellationSignal } from "../../../utils/task_canceller";
-import { PlaybackObserver } from "../../api";
-
-/** Event emitted when trying to perform the initial `play`. */
-export type IInitialPlayEvent =
-  /** Autoplay is not enabled, but all required steps to do so are there. */
-  { type: "skipped" } |
-  /**
-   * Tried to play, but autoplay is blocked by the browser.
-   * A corresponding warning should have already been sent.
-   */
-  { type: "autoplay-blocked" } |
-  /** Autoplay was done with success. */
-  { type: "autoplay" };
-
-/** Object returned by `initialSeekAndPlay`. */
-export interface IInitialSeekAndPlayObject {
-  /** Emit the result of the auto-play operation, once performed. */
-  autoPlayResult : Promise<IInitialPlayEvent>;
-
-  /**
-   * Shared reference whose value becomes `true` once the initial seek has
-   * been considered / has been done by `performInitialSeekAndPlay`.
-   */
-  initialSeekPerformed : IReadOnlySharedReference<boolean>;
-
-  /**
-   * Shared reference whose value becomes `true` once the initial play has
-   * been considered / has been done by `performInitialSeekAndPlay`.
-   */
-  initialPlayPerformed: IReadOnlySharedReference<boolean>;
-}
-
-/**
- * Seek as soon as possible at the initially wanted position and play if
- * autoPlay is wanted.
- * @param {HTMLMediaElement} mediaElement
- * @param {Object} playbackObserver
- * @param {number|Function} startTime
- * @param {boolean} mustAutoPlay
- * @param {Function} onWarning
- * @param {boolean} isDirectfile
- * @param {Object} cancelSignal
- * @returns {Object}
- */
-export default function performInitialSeekAndPlay(
-  mediaElement : HTMLMediaElement,
-  playbackObserver : PlaybackObserver,
-  startTime : number|(() => number),
-  mustAutoPlay : boolean,
-  onWarning : (err : IPlayerError) => void,
-  isDirectfile : boolean,
-  cancelSignal : CancellationSignal
-) : IInitialSeekAndPlayObject {
-  let resolveAutoPlay : (x : IInitialPlayEvent) => void;
-  let rejectAutoPlay : (x : unknown) => void;
-  const autoPlayResult = new Promise<IInitialPlayEvent>((res, rej) => {
-    resolveAutoPlay = res;
-    rejectAutoPlay = rej;
-  });
-
-  const initialSeekPerformed = new SharedReference(false, cancelSignal);
-  const initialPlayPerformed = new SharedReference(false, cancelSignal);
-
-  mediaElement.addEventListener("loadedmetadata", onLoadedMetadata);
-
-  const deregisterCancellation = cancelSignal.register((err : CancellationError) => {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-    rejectAutoPlay(err);
-  });
-
-  if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
-    onLoadedMetadata();
-  }
-
-  return { autoPlayResult, initialPlayPerformed, initialSeekPerformed };
-
-  function onLoadedMetadata() {
-    mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
-
-    /** `true` if we asked the `PlaybackObserver` to perform an initial seek. */
-    let hasAskedForInitialSeek = false;
-
-    const performInitialSeek = (initialSeekTime: number) => {
-      log.info("Init: Set initial time", initialSeekTime);
-      playbackObserver.setCurrentTime(initialSeekTime);
-      hasAskedForInitialSeek = true;
-      initialSeekPerformed.setValue(true);
-      initialSeekPerformed.finish();
-    };
-
-    // `startTime` defined as a function might depend on metadata to make its
-    // choice, such as the content duration, minimum and/or maximum position.
-    //
-    // The RxPlayer might already know those through the Manifest file for
-    // non-Directfile contents, yet only through the `HTMLMediaElement` once a
-    // a sufficient `readyState` has been reached for directfile contents.
-    // So let's divide the two possibilities here.
-    const initialTime = typeof startTime === "function" ? startTime() :
-                                                          startTime;
-    if (shouldPreventSeekingAt0Initially() && initialTime === 0) {
-      initialSeekPerformed.setValue(true);
-      initialSeekPerformed.finish();
-    } else if (isDirectfile && isSafariMobile) {
-      // On safari mobile (version 17.1.2) seeking too early cause the video
-      // to never buffer media data. Using setTimeout 0 defers the seek
-      // to a moment at which safari should be more able to handle a seek.
-      setTimeout(() => {
-        performInitialSeek(initialTime);
-      }, 0);
-    } else {
-      performInitialSeek(initialTime);
-    }
-
-    if (shouldValidateMetadata() && mediaElement.duration === 0) {
-      const error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA",
-                                   "Cannot load automatically: your browser " +
-                                   "falsely announced having loaded the content.");
-      onWarning(error);
-    }
-    if (cancelSignal.isCancelled()) {
-      return ;
-    }
-
-    /**
-     * We only want to continue to `play` when a `seek` has actually been
-     * performed (if it has been asked). This boolean keep track of if the
-     * seek arised.
-     */
-    let isAwaitingSeek = hasAskedForInitialSeek;
-    playbackObserver.listen((observation, stopListening) => {
-      if (hasAskedForInitialSeek && observation.seeking) {
-        isAwaitingSeek = false;
-        return;
-      }
-      if (!isAwaitingSeek &&
-          !observation.seeking &&
-          observation.rebuffering === null &&
-          observation.readyState >= 1)
-      {
-        stopListening();
-        onPlayable();
-      }
-    }, { includeLastObservation: true, clearSignal: cancelSignal });
-  }
-
-  function onPlayable() {
-    log.info("Init: Can begin to play content");
-    if (!mustAutoPlay) {
-      if (mediaElement.autoplay) {
-        log.warn("Init: autoplay is enabled on HTML media element. " +
-                 "Media will play as soon as possible.");
-      }
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({ type: "skipped" as const });
-    } else if (mediaElement.ended) {
-      // the video has ended state to true, executing VideoElement.play() will
-      // restart the video from the start, which is not wanted in most cases.
-      // returning "skipped" prevents the call to play() and fix the issue
-      log.warn("Init: autoplay is enabled but the video is ended. " +
-        "Skipping autoplay to prevent video to start again");
-      initialPlayPerformed.setValue(true);
-      initialPlayPerformed.finish();
-      deregisterCancellation();
-      return resolveAutoPlay({ type: "skipped" as const });
-    }
-
-    let playResult : Promise<unknown>;
-    try {
-      playResult = mediaElement.play() ?? Promise.resolve();
-    } catch (playError) {
-      deregisterCancellation();
-      return rejectAutoPlay(playError);
-    }
-    playResult
-      .then(() => {
-        if (cancelSignal.isCancelled()) {
-          return;
-        }
-        initialPlayPerformed.setValue(true);
-        initialPlayPerformed.finish();
-        deregisterCancellation();
-        return resolveAutoPlay({ type: "autoplay" as const });
-      })
-      .catch((playError : unknown) => {
-        deregisterCancellation();
-        if (cancelSignal.isCancelled()) {
-          return;
-        }
-        if (playError instanceof Error && playError.name === "NotAllowedError") {
-          // auto-play was probably prevented.
-          log.warn("Init: Media element can't play." +
-                   " It may be due to browser auto-play policies.");
-
-          const error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY",
-                                       "Cannot trigger auto-play automatically: " +
-                                       "your browser does not allow it.");
-          onWarning(error);
-          if (cancelSignal.isCancelled()) {
-            return;
-          }
-          return resolveAutoPlay({ type: "autoplay-blocked" as const });
-        } else {
-          rejectAutoPlay(playError);
-        }
-      });
-  }
-}

package/src/core/init/utils/initialize_content_decryption.ts

@@ -1,172 +0,0 @@
-import { EncryptedMediaError } from "../../../errors";
-import features from "../../../features";
-import log from "../../../log";
-import {
-  IKeySystemOption,
-  IPlayerError,
-} from "../../../public_types";
-import SharedReference, {
-  IReadOnlySharedReference,
-} from "../../../utils/reference";
-import TaskCanceller, {
-  CancellationSignal,
-} from "../../../utils/task_canceller";
-import {
-  ContentDecryptorState,
-  IContentProtection,
-} from "../../decrypt";
-
-/**
- * Initialize content decryption capabilities on the given `HTMLMediaElement`.
- *
- * You can call this function even if you don't want decrytpion capabilities, in
- * which case you can just set the `keySystems` option as an empty array.
- * In this situation, the returned object will directly correspond to an
- * "`initialized`" state and the `onError` callback will be triggered as soon
- * as protection information is received.
- *
- * @param {HTMLMediaElement} mediaElement - `HTMLMediaElement` on which content
- * decryption may be wanted.
- * @param {Array.<Object>} keySystems - Key system configuration(s) wanted
- * Empty array if no content decryption capability is wanted.
- * @param {Object} protectionRef - Reference through which content
- * protection initialization data will be sent through.
- * @param {Object} callbacks - Callbacks called at various decryption-related
- * events.
- * @param {Object} cancelSignal - When that signal emits, this function will
- * stop listening to various events as well as items sent through the
- * `protectionRef` parameter.
- * @returns {Object} - Reference emitting the current status regarding DRM
- * initialization.
- */
-export default function initializeContentDecryption(
-  mediaElement : HTMLMediaElement,
-  keySystems : IKeySystemOption[],
-  protectionRef : IReadOnlySharedReference<null | IContentProtection>,
-  callbacks : { onWarning : (err : IPlayerError) => void;
-                onError : (err : Error) => void; },
-  cancelSignal : CancellationSignal
-) : IReadOnlySharedReference<IDrmInitializationStatus> {
-  if (keySystems.length === 0) {
-    return createEmeDisabledReference("No `keySystems` option given.");
-  } else if (features.decrypt === null) {
-    return createEmeDisabledReference("EME feature not activated.");
-  }
-
-  const decryptorCanceller = new TaskCanceller();
-  decryptorCanceller.linkToSignal(cancelSignal);
-  const drmStatusRef = new SharedReference<IDrmInitializationStatus>({
-    initializationState: { type: "uninitialized", value: null },
-    drmSystemId: undefined,
-  }, cancelSignal);
-
-  const ContentDecryptor = features.decrypt;
-
-  if (!ContentDecryptor.hasEmeApis()) {
-    return createEmeDisabledReference("EME API not available on the current page.");
-  }
-
-  log.debug("Init: Creating ContentDecryptor");
-  const contentDecryptor = new ContentDecryptor(mediaElement, keySystems);
-
-  contentDecryptor.addEventListener("stateChange", (state) => {
-    if (state === ContentDecryptorState.WaitingForAttachment) {
-
-      const isMediaLinked = new SharedReference(false);
-      isMediaLinked.onUpdate((isAttached, stopListening) => {
-        if (isAttached) {
-          stopListening();
-          if (state === ContentDecryptorState.WaitingForAttachment) {
-            contentDecryptor.attach();
-          }
-        }
-      }, { clearSignal: decryptorCanceller.signal });
-      drmStatusRef.setValue({ initializationState: { type: "awaiting-media-link",
-                                                     value: { isMediaLinked } },
-                              drmSystemId: contentDecryptor.systemId });
-    } else if (state === ContentDecryptorState.ReadyForContent) {
-      drmStatusRef.setValue({ initializationState: { type: "initialized",
-                                                     value: null },
-                              drmSystemId: contentDecryptor.systemId });
-      contentDecryptor.removeEventListener("stateChange");
-    }
-  });
-
-  contentDecryptor.addEventListener("error", (error) => {
-    decryptorCanceller.cancel();
-    callbacks.onError(error);
-  });
-
-  contentDecryptor.addEventListener("warning", (error) => {
-    callbacks.onWarning(error);
-  });
-
-  protectionRef.onUpdate((data) => {
-    if (data === null) {
-      return;
-    }
-    contentDecryptor.onInitializationData(data);
-  }, { clearSignal: decryptorCanceller.signal });
-
-  decryptorCanceller.signal.register(() => {
-    contentDecryptor.dispose();
-  });
-
-  return drmStatusRef;
-
-  function createEmeDisabledReference(errMsg : string) {
-    protectionRef.onUpdate((data, stopListening) => {
-      if (data === null) { // initial value
-        return;
-      }
-      stopListening();
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
-      callbacks.onError(err);
-    }, { clearSignal: cancelSignal });
-    const ref = new SharedReference({
-      initializationState: { type: "initialized" as const, value: null },
-      drmSystemId: undefined });
-    ref.finish(); // We know that no new value will be triggered
-    return ref;
-  }
-}
-
-/** Status of content decryption initialization. */
-interface IDrmInitializationStatus {
-  /** Current initialization state the decryption logic is in. */
-  initializationState : IDecryptionInitializationState;
-  /**
-   * If set, corresponds to the hex string describing the current key system
-   * used.
-   * `undefined` if unknown or if it does not apply.
-   */
-  drmSystemId : string | undefined;
-}
-
-/** Initialization steps to add decryption capabilities to an `HTMLMediaElement`. */
-type IDecryptionInitializationState =
-  /**
-   * Decryption capabilities have not been initialized yet.
-   * You should wait before performing any action on the concerned
-   * `HTMLMediaElement` (such as linking a content / `MediaSource` to it).
-   */
-  { type: "uninitialized"; value: null } |
-  /**
-   * The `MediaSource` or media url has to be linked to the `HTMLMediaElement`
-   * before continuing.
-   * Once it has been linked with success (e.g. the `MediaSource` has "opened"),
-   * the `isMediaLinked` `SharedReference` should be set to `true`.
-   *
-   * In the `MediaSource` case, you should wait until the `"initialized"`
-   * state before pushing segment.
-   *
-   * Note that the `"awaiting-media-link"` is an optional state. It can be
-   * skipped to directly `"initialized"` instead.
-   */
-  { type: "awaiting-media-link";
-    value: { isMediaLinked : SharedReference<boolean> }; } |
-  /**
-   * The `MediaSource` or media url can be linked AND segments can be pushed to
-   * the `HTMLMediaElement` on which decryption capabilities were wanted.
-   */
-  { type: "initialized"; value: null };