react-native-theoplayer 1.8.2 → 2.0.0

package/src/api/event/EventDispatcher.ts

@@ -0,0 +1,48 @@
+import type { Event } from './Event';
+import type { EventListener } from './EventListener';
+
+/**
+ * A record used to map events.
+ * Each entry contains an event name with associated event interface.
+ *
+ * @example
+ * ```
+ * {
+ *   'statechange': StateChangeEvent,
+ *   'error': ErrorEvent
+ * }
+ * ```
+ *
+ * @public
+ */
+export type EventMap<TType extends string> = Record<TType, Event<TType>>;
+
+/**
+ * Helper type to extract string keys from type objects.
+ *
+ * @public
+ */
+export type StringKeyOf<T> = Extract<keyof T, string>;
+
+/**
+ * Dispatches events that are fired.
+ *
+ * @public
+ */
+export interface EventDispatcher<TEventMap extends EventMap<StringKeyOf<TEventMap>>> {
+  /**
+   * Add the given listener for the given event type(s).
+   *
+   * @param type - The type of the event.
+   * @param listener - The callback which is executed when the event occurs.
+   */
+  addEventListener<TType extends StringKeyOf<TEventMap>>(type: TType | readonly TType[], listener: EventListener<TEventMap[TType]>): void;
+
+  /**
+   * Remove the given listener for the given event type(s).
+   *
+   * @param type - The type of the event.
+   * @param listener - The callback which will be removed.
+   */
+  removeEventListener<TType extends StringKeyOf<TEventMap>>(type: TType | readonly TType[], listener: EventListener<TEventMap[TType]>): void;
+}

package/src/api/event/EventListener.ts

@@ -0,0 +1,8 @@
+import type { Event } from './Event';
+
+/**
+ * The function to be executed when an event occurred.
+ *
+ * @public
+ */
+export type EventListener<TEvent extends Event> = (event: TEvent) => void;

package/src/api/event/PlayerEvent.ts

@@ -1,11 +1,12 @@
-import type { MediaTrack, PlayerError, TextTrack } from 'react-native-theoplayer';
+import type { MediaTrack, PlayerError, PlayerEventType, PresentationMode, TextTrack } from 'react-native-theoplayer';
 import type { TimeRange } from '../timeranges/TimeRange';
+import type { Event } from './Event';
 
-export interface ErrorEvent {
+export interface ErrorEvent extends Event<PlayerEventType.ERROR> {
   error: PlayerError;
 }
 
-export interface LoadedMetadataEvent {
+export interface LoadedMetadataEvent extends Event<PlayerEventType.LOADED_METADATA> {
   textTracks: TextTrack[];
   audioTracks: MediaTrack[];
   videoTracks: MediaTrack[];
@@ -15,7 +16,7 @@ export interface LoadedMetadataEvent {
   selectedAudioTrack: number | undefined;
 }
 
-export interface TimeUpdateEvent {
+export interface TimeUpdateEvent extends Event<PlayerEventType.TIME_UPDATE> {
   /**
    * The player's current time, in msecs.
    */
@@ -27,28 +28,88 @@ export interface TimeUpdateEvent {
   readonly currentProgramDateTime?: number;
 }
 
-export interface DurationChangeEvent {
+export interface DurationChangeEvent extends Event<PlayerEventType.DURATION_CHANGE> {
   /**
    * The player's new duration, in msecs.
    */
   readonly duration: number;
 }
 
-export interface ReadyStateChangeEvent {
+export enum PresentationModeChangePipContext {
+  /**
+   * The PiP window was explicitly closed.
+   */
+  CLOSED = 'closed',
+
+  /**
+   * The PiP window was restored/maximized.
+   */
+  RESTORED = 'restored',
+}
+
+export interface PresentationModeChangeContext {
+  /**
+   * The PiP context for presentationMode change.
+   */
+  readonly pip: PresentationModeChangePipContext;
+}
+
+export interface PresentationModeChangeEvent extends Event<PlayerEventType.PRESENTATIONMODE_CHANGE> {
+  /**
+   * The player's new presentationMode.
+   */
+  readonly presentationMode: PresentationMode;
+
+  /**
+   * The player's previous presentationMode.
+   */
+  readonly previousPresentationMode: PresentationMode;
+
+  /**
+   * The context for presentationMode change.
+   */
+  readonly context?: PresentationModeChangeContext;
+}
+
+export interface RateChangeEvent extends Event<PlayerEventType.RATE_CHANGE> {
+  /**
+   * The player's new playback rate.
+   */
+  readonly playbackRate: number;
+}
+
+export interface ReadyStateChangeEvent extends Event<PlayerEventType.READYSTATE_CHANGE> {
   /**
    * The player's new ready state.
    */
   readonly readyState: number;
 }
 
-export interface ProgressEvent {
+export interface VolumeChangeEvent extends Event<PlayerEventType.VOLUME_CHANGE> {
+  /**
+   * The player's new volume.
+   */
+  readonly volume: number;
+
+  /**
+   * The player's muted state.
+   */
+  readonly muted: boolean;
+}
+
+export interface ProgressEvent extends Event<PlayerEventType.PROGRESS> {
   /**
    * The ranges of the media resource that are seekable by the player.
    */
   readonly seekable: TimeRange[];
+
+  /**
+   * The ranges of the media resource that are buffered by the player.
+   */
+  readonly buffered: TimeRange[];
 }
 
-export interface SegmentNotFoundEvent {
+export interface SegmentNotFoundEvent extends Event<PlayerEventType.SEGMENT_NOT_FOUND> {
   /**
    * Start time of the segment.
    */

package/src/api/event/TrackEvent.ts

@@ -2,32 +2,28 @@ import type { TextTrack } from '../track/TextTrack';
 import type { TextTrackCue } from '../track/TextTrackCue';
 import type { MediaTrack } from '../track/MediaTrack';
 import type { Quality } from '../track/Quality';
+import type { Event } from './Event';
+import type { PlayerEventType } from '../player/PlayerEventMap';
 
 export enum TrackListEventType {
   /**
    * Dispatched when track has been added to the track list.
    */
-  AddTrack,
+  ADD_TRACK = 'addtrack',
 
   /**
    * Dispatched when track has been removed from the track list.
    */
-  RemoveTrack,
+  REMOVE_TRACK = 'removetrack',
 
   /**
    * Fired when a track has been changed.
    */
-  ChangeTrack,
+  CHANGE_TRACK = 'changetrack',
 }
 
-export interface TrackListEvent {
-  /**
-   * The type of track list event.
-   */
-  readonly type: TrackListEventType;
-}
-
-export interface TextTrackListEvent extends TrackListEvent {
+export interface TextTrackListEvent extends Event<PlayerEventType.TEXT_TRACK_LIST> {
+  readonly subType: TrackListEventType;
   /**
    * The relevant text track.
    */
@@ -38,20 +34,26 @@ export enum TextTrackEventType {
   /**
    * Dispatched when cue has been added to the text track.
    */
-  AddCue,
+  ADD_CUE = 'addcue',
 
   /**
    * Dispatched when cue has been removed from the text track.
    */
-  RemoveCue,
-}
+  REMOVE_CUE = 'removecue',
+
+  /**
+   * Dispatched when a cue of the track enters.
+   */
+  ENTER_CUE = 'entercue',
 
-export interface TextTrackEvent {
   /**
-   * The type of text track event.
+   * Dispatched when a cue of the track exits.
    */
-  readonly type: TextTrackEventType;
+  EXIT_CUE = 'exitcue',
+}
 
+export interface TextTrackEvent extends Event<PlayerEventType.TEXT_TRACK> {
+  readonly subType: TextTrackEventType;
   /**
    * The text track's uid to which this cue belongs.
    */
@@ -64,14 +66,15 @@ export interface TextTrackEvent {
 }
 
 export enum MediaTrackType {
-  Audio,
+  AUDIO = 'audio',
 
-  Video,
+  VIDEO = 'video',
 }
 
-export interface MediaTrackListEvent extends TrackListEvent {
+export interface MediaTrackListEvent extends Event<PlayerEventType.MEDIA_TRACK_LIST> {
+  readonly subType: TrackListEventType;
   /**
-   * The relevant media track type, either {@link MediaTrackType.Audio} or {@link MediaTrackType.Video}.
+   * The relevant media track type, either {@link MediaTrackType.AUDIO} or {@link MediaTrackType.VIDEO}.
    */
   readonly trackType: MediaTrackType;
 
@@ -85,17 +88,13 @@ export enum MediaTrackEventType {
   /**
    * Dispatched when the media track's active quality changes.
    */
-  ActiveQualityChanged,
+  ACTIVE_QUALITY_CHANGED = 'activequalitychanged',
 }
 
-export interface MediaTrackEvent {
-  /**
-   * The type of media track event.
-   */
-  readonly type: MediaTrackEventType;
-
+export interface MediaTrackEvent extends Event<PlayerEventType.MEDIA_TRACK> {
+  readonly subType: MediaTrackEventType;
   /**
-   * The media track's type to which event belongs, either {@link MediaTrackType.Audio} or {@link MediaTrackType.Video}.
+   * The media track's type to which event belongs, either {@link MediaTrackType.AUDIO} or {@link MediaTrackType.VIDEO}.
    */
   readonly trackType: MediaTrackType;
 

package/src/api/event/barrel.ts

@@ -2,3 +2,4 @@ export * from './AdEvent';
 export * from './CastEvent';
 export * from './PlayerEvent';
 export * from './TrackEvent';
+export * from './Event';

package/src/api/media/MediaControlConfiguration.ts

@@ -0,0 +1,26 @@
+/**
+ * Describes the configuration of media controls and media sessions across platforms.
+ *
+ * For Android, this applies to the {@link https://developer.android.com/guide/topics/media-apps/working-with-a-media-session Media Session}
+ * functionality, providing the platform with a uniform way of interacting with the player, and the
+ * {@link https://developer.android.com/develop/ui/views/notifications Notification to display information on the media currently playing.
+ *
+ * For Web, this applies to the {@link https://www.w3.org/TR/mediasession/ Media Session} API for customizing media notifications and access to
+ * platform media keys.
+ *
+ * For iOS, this applies to the {@link https://developer.apple.com/documentation/mediaplayer/mpnowplayinginfocenter Now Playing} functionality for
+ * setting information on the media that is currently playing, and the
+ * {@link https://developer.apple.com/documentation/mediaplayer/mpremotecommandcenter Remote Command Center} responds to remote control events sent
+ * by external accessories and system controls.
+ */
+export interface MediaControlConfiguration {
+  /**
+   * Whether the media session feature is enabled.
+   *
+   * @defaultValue `true`
+   *
+   * @remarks
+   * <br/> - This only applies to Web.
+   */
+  readonly mediaSessionEnabled?: boolean;
+}

package/src/api/media/barrel.ts

@@ -0,0 +1 @@
+export * from './MediaControlConfiguration';

package/src/api/pip/PiPConfiguration.ts

@@ -0,0 +1,13 @@
+/**
+ * Describes the configuration of the picture-in-picture feature.
+ *
+ * @public
+ */
+export interface PiPConfiguration {
+  /**
+   * Whether Picture in Picture should be allowed to start automatically when transitioning to background.
+   *
+   * @defaultValue `false`
+   */
+  readonly startsAutomatically?: boolean;
+}

package/src/api/pip/barrel.ts

@@ -0,0 +1 @@
+export * from './PiPConfiguration';

package/src/api/player/PlayerEventMap.ts

@@ -0,0 +1,198 @@
+import type { Event } from '../event/Event';
+import type {
+  DurationChangeEvent,
+  ErrorEvent,
+  LoadedMetadataEvent,
+  ProgressEvent,
+  RateChangeEvent,
+  ReadyStateChangeEvent,
+  SegmentNotFoundEvent,
+  TimeUpdateEvent,
+  PresentationModeChangeEvent,
+  VolumeChangeEvent,
+} from '../event/PlayerEvent';
+import type { MediaTrackEvent, MediaTrackListEvent, TextTrackEvent, TextTrackListEvent } from '../event/TrackEvent';
+import type { AdEvent } from '../event/AdEvent';
+import type { CastEvent } from '../event/CastEvent';
+
+export enum PlayerEventType {
+  PLAY = 'play',
+  CANPLAY = 'canplay',
+  PLAYING = 'playing',
+  SOURCE_CHANGE = 'sourcechange',
+  LOAD_START = 'loadstart',
+  LOADED_METADATA = 'loadedmetadata',
+  LOADED_DATA = 'loadeddata',
+  READYSTATE_CHANGE = 'readystatechange',
+  ERROR = 'error',
+  PROGRESS = 'progress',
+  PAUSE = 'pause',
+  SEEKING = 'seeking',
+  SEEKED = 'seeked',
+  ENDED = 'ended',
+  TIME_UPDATE = 'timeupdate',
+  DURATION_CHANGE = 'durationchange',
+  RATE_CHANGE = 'ratechange',
+  SEGMENT_NOT_FOUND = 'segmentnotfound',
+  TEXT_TRACK_LIST = 'texttracklist',
+  TEXT_TRACK = 'texttrack',
+  MEDIA_TRACK_LIST = 'mediatracklist',
+  MEDIA_TRACK = 'mediatrack',
+  AD_EVENT = 'adevent',
+  CAST_EVENT = 'castevent',
+  VOLUME_CHANGE = 'volumechange',
+  WAITING = 'waiting',
+  PRESENTATIONMODE_CHANGE = 'presentationmodechange',
+  DESTROY = 'destroy',
+}
+
+/**
+ * The events dispatched by THEOplayer.
+ *
+ */
+export interface PlayerEventMap {
+  /**
+   * Dispatched when the player can resume playback of the media data.
+   */
+  [PlayerEventType.CANPLAY]: Event<PlayerEventType.CANPLAY>;
+
+  /**
+   * Dispatched when the player's internal paused state changes to `false`.
+   */
+  [PlayerEventType.PLAY]: Event<PlayerEventType.PLAY>;
+
+  /**
+   * Dispatched when playback is ready to start after having been paused or delayed due to lack of media data.
+   */
+  [PlayerEventType.PLAYING]: Event<PlayerEventType.PLAYING>;
+
+  /**
+   * Dispatched when the presentationMode of the player changes.
+   */
+  [PlayerEventType.PRESENTATIONMODE_CHANGE]: PresentationModeChangeEvent;
+
+  /**
+   * Dispatched when the player's source changes.
+   */
+  [PlayerEventType.SOURCE_CHANGE]: Event<PlayerEventType.SOURCE_CHANGE>;
+
+  /**
+   * Dispatched when the player starts loading the manifest.
+   */
+  [PlayerEventType.LOAD_START]: Event<PlayerEventType.LOAD_START>;
+
+  /**
+   * Dispatched when the player determines the metadata for its source.
+   */
+  [PlayerEventType.LOADED_METADATA]: LoadedMetadataEvent;
+
+  /**
+   * Dispatched when the player can render the media data at the current playback position for the first time.
+   */
+  [PlayerEventType.LOADED_DATA]: Event<PlayerEventType.LOADED_DATA>;
+
+  /**
+   * Dispatched when the player's readyState has changed.
+   */
+  [PlayerEventType.READYSTATE_CHANGE]: ReadyStateChangeEvent;
+
+  /**
+   * Dispatched when the player's volume changes.
+   */
+  [PlayerEventType.VOLUME_CHANGE]: VolumeChangeEvent;
+
+  /**
+   * Dispatched when an error occurs.
+   */
+  [PlayerEventType.ERROR]: ErrorEvent;
+
+  /**
+   * Dispatched each time the player has loaded media data.
+   */
+  [PlayerEventType.PROGRESS]: ProgressEvent;
+
+  /**
+   * Dispatched when the player's internal paused state changes to `true`.
+   */
+  [PlayerEventType.PAUSE]: Event<PlayerEventType.PAUSE>;
+
+  /**
+   * Dispatched when a seek operation starts and the player is seeking a new position.
+   */
+  [PlayerEventType.SEEKING]: Event<PlayerEventType.SEEKING>;
+
+  /**
+   * Dispatched when a seek operation completed and the current playback position has changed.
+   */
+  [PlayerEventType.SEEKED]: Event<PlayerEventType.SEEKED>;
+
+  /**
+   * Dispatched when playback has stopped because the end of the media was reached or because
+   * no further data is available.
+   */
+  [PlayerEventType.ENDED]: Event<PlayerEventType.ENDED>;
+
+  /**
+   * Dispatched when playback has stopped because the next frame is not available, but the
+   * player expects that frame to become available in due course.
+   */
+  [PlayerEventType.WAITING]: Event<PlayerEventType.WAITING>;
+
+  /**
+   * Dispatched each time the current playback position changed.
+   */
+  [PlayerEventType.TIME_UPDATE]: TimeUpdateEvent;
+
+  /**
+   * Dispatched when the player's duration attribute has been updated.
+   */
+  [PlayerEventType.DURATION_CHANGE]: DurationChangeEvent;
+
+  /**
+   * Dispatched when the player's playbackRate changes.
+   */
+  [PlayerEventType.RATE_CHANGE]: RateChangeEvent;
+
+  /**
+   * Dispatched when a segment can not be found.
+   *
+   * @remarks
+   * <br/> - Only dispatched on DASH streams.
+   */
+  [PlayerEventType.SEGMENT_NOT_FOUND]: SegmentNotFoundEvent;
+
+  /**
+   * Dispatched when a text track list event occurs.
+   */
+  [PlayerEventType.TEXT_TRACK_LIST]: TextTrackListEvent;
+
+  /**
+   * Dispatched when a text track event occurs.
+   */
+  [PlayerEventType.TEXT_TRACK]: TextTrackEvent;
+
+  /**
+   * Dispatched when a media track list event occurs.
+   */
+  [PlayerEventType.MEDIA_TRACK_LIST]: MediaTrackListEvent;
+
+  /**
+   * Dispatched when a media track event occurs.
+   */
+  [PlayerEventType.MEDIA_TRACK]: MediaTrackEvent;
+
+  /**
+   * Dispatched when an ad event occurs.
+   */
+  [PlayerEventType.AD_EVENT]: AdEvent;
+
+  /**
+   * Dispatched when a cast event occurs, either for Chromecast or Airplay.
+   */
+  [PlayerEventType.CAST_EVENT]: CastEvent;
+
+  /**
+   * Dispatched when the player will be destroyed.
+   */
+  [PlayerEventType.DESTROY]: Event<PlayerEventType.DESTROY>;
+}