react-native-theoplayer 1.8.2 → 2.0.0

package/src/internal/adapter/THEOplayerWebAdapter.ts

@@ -0,0 +1,275 @@
+import { DefaultEventDispatcher } from './event/DefaultEventDispatcher';
+import type {
+  AdsAPI,
+  CastAPI,
+  MediaTrack,
+  NativeHandleType,
+  PlayerEventMap,
+  PreloadType,
+  TextTrack,
+  TextTrackStyle,
+  THEOplayer,
+  PlayerConfiguration,
+} from 'react-native-theoplayer';
+import { THEOplayerWebAdsAdapter } from './ads/THEOplayerWebAdsAdapter';
+import { THEOplayerWebCastAdapter } from './cast/THEOplayerWebCastAdapter';
+import type * as THEOplayerWeb from 'theoplayer';
+import type { MediaTrack as NativeMediaTrack, TextTrack as NativeTextTrack } from 'theoplayer';
+import { findNativeQualitiesByUid, fromNativeMediaTrackList, fromNativeTextTrackList } from './web/TrackUtils';
+import type { ABRConfiguration, SourceDescription } from 'src/api/barrel';
+import { WebEventForwarder } from './WebEventForwarder';
+import type { PiPConfiguration } from 'src/api/pip/PiPConfiguration';
+import type { BackgroundAudioConfiguration } from 'src/api/backgroundAudio/BackgroundAudioConfiguration';
+import { WebPresentationModeManager } from './web/WebPresentationModeManager';
+import { WebMediaSession } from './web/WebMediaSession';
+import { PresentationMode } from 'react-native-theoplayer';
+
+const defaultBackgroundAudioConfiguration: BackgroundAudioConfiguration = {
+  enabled: false,
+};
+
+const defaultPipConfiguration: PiPConfiguration = {
+  startsAutomatically: false,
+};
+
+export class THEOplayerWebAdapter extends DefaultEventDispatcher<PlayerEventMap> implements THEOplayer {
+  private readonly _player: THEOplayerWeb.ChromelessPlayer;
+  private readonly _adsAdapter: THEOplayerWebAdsAdapter;
+  private readonly _castAdapter: THEOplayerWebCastAdapter;
+  private readonly _eventForwarder: WebEventForwarder;
+  private readonly _presentationModeManager: WebPresentationModeManager;
+  private readonly _mediaSession: WebMediaSession | undefined = undefined;
+  private _targetVideoQuality: number | number[] | undefined = undefined;
+  private _backgroundAudioConfiguration: BackgroundAudioConfiguration = defaultBackgroundAudioConfiguration;
+  private _pipConfiguration: PiPConfiguration = defaultPipConfiguration;
+
+  constructor(player: THEOplayerWeb.ChromelessPlayer, config?: PlayerConfiguration) {
+    super();
+    this._player = player;
+    this._adsAdapter = new THEOplayerWebAdsAdapter(this._player);
+    this._castAdapter = new THEOplayerWebCastAdapter(this._player);
+    this._eventForwarder = new WebEventForwarder(this._player, this);
+    this._presentationModeManager = new WebPresentationModeManager(this._player, this);
+    document.addEventListener('visibilitychange', this.onVisibilityChange);
+
+    // Optionally create a media session connector
+    if (config?.mediaControl?.mediaSessionEnabled !== false) {
+      this._mediaSession = new WebMediaSession(this, player);
+    }
+  }
+
+  get abr(): ABRConfiguration | undefined {
+    return this._player.abr;
+  }
+
+  get source(): SourceDescription | undefined {
+    return this._player.source as SourceDescription;
+  }
+
+  set source(source: SourceDescription | undefined) {
+    this._targetVideoQuality = undefined;
+    this._player.source = source;
+  }
+
+  play(): void {
+    this._player.play();
+  }
+
+  pause(): void {
+    this._player.pause();
+  }
+
+  get paused(): boolean {
+    return this._player.paused;
+  }
+
+  get autoplay(): boolean {
+    return this._player.autoplay;
+  }
+
+  set autoplay(autoplay: boolean) {
+    this._player.autoplay = autoplay;
+  }
+
+  set preload(type: PreloadType) {
+    this._player.preload = type;
+  }
+
+  get preload(): PreloadType {
+    return this._player.preload;
+  }
+
+  get seekable() {
+    const nativeRange = this._player.seekable;
+    return [...Array(nativeRange.length)].map((_, index) => ({ start: 1e3 * nativeRange.start(index), end: 1e3 * nativeRange.end(index) }));
+  }
+
+  get buffered() {
+    const nativeRange = this._player.buffered;
+    return [...Array(nativeRange.length)].map((_, index) => ({ start: 1e3 * nativeRange.start(index), end: 1e3 * nativeRange.end(index) }));
+  }
+
+  get playbackRate(): number {
+    return this._player.playbackRate;
+  }
+
+  set playbackRate(playbackRate: number) {
+    this._player.playbackRate = playbackRate;
+  }
+
+  get pipConfiguration(): PiPConfiguration {
+    return this._pipConfiguration;
+  }
+
+  set pipConfiguration(config: PiPConfiguration) {
+    this._pipConfiguration = config;
+  }
+
+  get backgroundAudioConfiguration(): BackgroundAudioConfiguration {
+    return this._backgroundAudioConfiguration;
+  }
+
+  set backgroundAudioConfiguration(config: BackgroundAudioConfiguration) {
+    this._backgroundAudioConfiguration = config;
+
+    // Notify media session
+    this._mediaSession?.updateActionHandlers();
+  }
+
+  get volume(): number {
+    return this._player.volume;
+  }
+
+  set volume(volume: number) {
+    this._player.volume = volume;
+  }
+
+  get muted(): boolean {
+    return this._player.muted;
+  }
+
+  set muted(muted: boolean) {
+    this._player.muted = muted;
+  }
+
+  get seeking(): boolean {
+    return this._player.seeking;
+  }
+
+  get presentationMode(): PresentationMode {
+    return this._presentationModeManager.presentationMode;
+  }
+
+  set presentationMode(presentationMode: PresentationMode) {
+    this._presentationModeManager.presentationMode = presentationMode;
+  }
+
+  get audioTracks(): MediaTrack[] {
+    return fromNativeMediaTrackList(this._player.audioTracks);
+  }
+
+  get videoTracks(): MediaTrack[] {
+    return fromNativeMediaTrackList(this._player.videoTracks);
+  }
+
+  get textTracks(): TextTrack[] {
+    return fromNativeTextTrackList(this._player.textTracks);
+  }
+
+  get selectedTextTrack(): number | undefined {
+    return this._player.textTracks.find((textTrack: NativeTextTrack) => {
+      return textTrack.mode === 'showing';
+    })?.uid;
+  }
+
+  set selectedTextTrack(selectedTextTrack: number | undefined) {
+    this._player.textTracks.forEach((textTrack: NativeTextTrack) => {
+      textTrack.mode = textTrack.uid === selectedTextTrack ? 'showing' : 'disabled';
+    });
+  }
+
+  get textTrackStyle(): TextTrackStyle {
+    return this._player.textTrackStyle as TextTrackStyle;
+  }
+
+  get selectedVideoTrack(): number | undefined {
+    return this._player.videoTracks.find((videoTrack: NativeMediaTrack) => videoTrack.enabled)?.uid;
+  }
+
+  set selectedVideoTrack(selectedVideoTrack: number | undefined) {
+    this._targetVideoQuality = undefined;
+    this._player.videoTracks.forEach((videoTrack: NativeMediaTrack) => {
+      videoTrack.enabled = videoTrack.uid === selectedVideoTrack;
+    });
+  }
+
+  get selectedAudioTrack(): number | undefined {
+    return this._player.audioTracks.find((audioTrack: NativeMediaTrack) => {
+      return audioTrack.enabled;
+    })?.uid;
+  }
+
+  set selectedAudioTrack(selectedAudioTrack: number | undefined) {
+    this._player.audioTracks.forEach((audioTrack: NativeMediaTrack) => {
+      audioTrack.enabled = audioTrack.uid === selectedAudioTrack;
+    });
+  }
+
+  get targetVideoQuality(): number | number[] | undefined {
+    return this._targetVideoQuality;
+  }
+
+  set targetVideoQuality(targetVideoQuality: number | number[] | undefined) {
+    const enabledVideoTrack = this._player.videoTracks.find((videoTrack: NativeMediaTrack) => videoTrack.enabled);
+    if (enabledVideoTrack) {
+      enabledVideoTrack.targetQuality = findNativeQualitiesByUid(enabledVideoTrack, targetVideoQuality);
+    }
+    this._targetVideoQuality = targetVideoQuality;
+  }
+
+  get currentTime(): number {
+    return 1e3 * this._player.currentTime;
+  }
+
+  set currentTime(currentTime: number) {
+    if (isNaN(currentTime)) {
+      return;
+    }
+    if (this._player) {
+      this._player.currentTime = currentTime / 1e3;
+    }
+  }
+
+  get duration(): number {
+    return this._player.duration * 1e3;
+  }
+
+  public get ads(): AdsAPI {
+    return this._adsAdapter;
+  }
+
+  public get cast(): CastAPI {
+    return this._castAdapter;
+  }
+
+  destroy(): void {
+    this._eventForwarder.unload();
+    this._mediaSession?.destroy();
+    document.removeEventListener('visibilitychange', this.onVisibilityChange);
+  }
+
+  get nativeHandle(): NativeHandleType {
+    return this._player;
+  }
+
+  private readonly onVisibilityChange = () => {
+    if (document.visibilityState !== 'visible') {
+      // Apply background configuration: by default, pause when going to background, unless in pip
+      if (this.presentationMode !== PresentationMode.pip && !this.backgroundAudioConfiguration.enabled) {
+        this._player.pause();
+      }
+    }
+    // Apply media session controls
+    this._mediaSession?.updateActionHandlers();
+  };
+}

package/src/internal/adapter/WebEventForwarder.ts

@@ -0,0 +1,399 @@
+import type * as THEOplayer from 'theoplayer';
+import type {
+  AddTrackEvent,
+  CastStateChangeEvent,
+  ChromecastErrorEvent,
+  DurationChangeEvent as NativeDurationChangeEvent,
+  ErrorEvent as NativeErrorEvent,
+  Event as NativeEvent,
+  MediaTrack as NativeMediaTrack,
+  PresentationModeChangeEvent,
+  RateChangeEvent as NativeRateChangeEvent,
+  ReadyStateChangeEvent as NativeReadyStateChangeEvent,
+  RemoveTrackEvent,
+  TextTrack as NativeTextTrack,
+  TextTrackCue as NativeTextTrackCue,
+  TimeUpdateEvent as NativeTimeUpdateEvent,
+  TrackChangeEvent,
+  VolumeChangeEvent as NativeVolumeChangeEvent,
+} from 'theoplayer';
+import type { AdEvent, MediaTrack, TextTrack, TimeRange } from 'react-native-theoplayer';
+import {
+  AdEventType,
+  CastState,
+  MediaTrackEventType,
+  MediaTrackType,
+  PlayerEventType,
+  PresentationMode,
+  TextTrackEventType,
+  TrackListEventType,
+} from 'react-native-theoplayer';
+import type { THEOplayerWebAdapter } from './THEOplayerWebAdapter';
+import { BaseEvent } from './event/BaseEvent';
+import {
+  DefaultAdEvent,
+  DefaultAirplayStateChangeEvent,
+  DefaultChromecastChangeEvent,
+  DefaultChromecastErrorEvent,
+  DefaultDurationChangeEvent,
+  DefaultErrorEvent,
+  DefaultLoadedMetadataEvent,
+  DefaultMediaTrackEvent,
+  DefaultMediaTrackListEvent,
+  DefaultPresentationModeChangeEvent,
+  DefaultProgressEvent,
+  DefaultRateChangeEvent,
+  DefaultReadyStateChangeEvent,
+  DefaultSegmentNotFoundEvent,
+  DefaultTextTrackEvent,
+  DefaultTextTrackListEvent,
+  DefaultTimeupdateEvent,
+  DefaultVolumeChangeEvent,
+} from './event/PlayerEvents';
+import { fromNativeCue, fromNativeMediaTrack, fromNativeTextTrack } from './web/TrackUtils';
+
+export class WebEventForwarder {
+  private readonly _player: THEOplayer.ChromelessPlayer;
+  private readonly _facade: THEOplayerWebAdapter;
+
+  constructor(player: THEOplayer.ChromelessPlayer, facade: THEOplayerWebAdapter) {
+    this._player = player;
+    this._facade = facade;
+    this.addEventListeners();
+  }
+
+  private addEventListeners() {
+    this._player.addEventListener('sourcechange', this.onSourceChange);
+    this._player.addEventListener('loadstart', this.onLoadStart);
+    this._player.addEventListener('loadeddata', this.onLoadedData);
+    this._player.addEventListener('loadedmetadata', this.onLoadedMetadata);
+    this._player.addEventListener('error', this.onError);
+    this._player.addEventListener('progress', this.onProgress);
+    this._player.addEventListener('play', this.onPlay);
+    this._player.addEventListener('canplay', this.onCanPlay);
+    this._player.addEventListener('playing', this.onPlaying);
+    this._player.addEventListener('pause', this.onPause);
+    this._player.addEventListener('seeking', this.onSeeking);
+    this._player.addEventListener('seeked', this.onSeeked);
+    this._player.addEventListener('ended', this.onEnded);
+    this._player.addEventListener('waiting', this.onWaiting);
+    this._player.addEventListener('readystatechange', this.onReadyStateChanged);
+    this._player.addEventListener('timeupdate', this.onTimeUpdate);
+    this._player.addEventListener('durationchange', this.onDurationChange);
+    this._player.addEventListener('ratechange', this.onPlaybackRateChange);
+    this._player.addEventListener('segmentnotfound', this.onSegmentNotFound);
+    this._player.addEventListener('volumechange', this.onVolumeChangeEvent);
+    this._player.presentation.addEventListener('presentationmodechange', this.onPresentationModeChange);
+
+    this._player.textTracks.addEventListener('addtrack', this.onAddTextTrack);
+    this._player.textTracks.addEventListener('removetrack', this.onRemoveTextTrack);
+    this._player.textTracks.addEventListener('change', this.onChangeTextTrack);
+
+    this._player.audioTracks.addEventListener('addtrack', this.onAddAudioTrack);
+    this._player.audioTracks.addEventListener('removetrack', this.onRemoveAudioTrack);
+    this._player.audioTracks.addEventListener('change', this.onChangeAudioTrack);
+
+    this._player.videoTracks.addEventListener('addtrack', this.onAddVideoTrack);
+    this._player.videoTracks.addEventListener('removetrack', this.onRemoveVideoTrack);
+    this._player.videoTracks.addEventListener('change', this.onChangeVideoTrack);
+
+    this._player.cast?.chromecast?.addEventListener('statechange', this.onChromecastStateChange);
+    this._player.cast?.chromecast?.addEventListener('error', this.onChromecastError);
+    this._player.cast?.airplay?.addEventListener('statechange', this.onAirplayStateChange);
+
+    this._player.ads?.addEventListener(FORWARDED_AD_EVENTS, this.onAdEvent);
+  }
+
+  unload(): void {
+    this.removeEventListeners();
+  }
+
+  private removeEventListeners() {
+    this._player.removeEventListener('sourcechange', this.onSourceChange);
+    this._player.removeEventListener('loadstart', this.onLoadStart);
+    this._player.removeEventListener('loadeddata', this.onLoadedData);
+    this._player.removeEventListener('loadedmetadata', this.onLoadedMetadata);
+    this._player.removeEventListener('error', this.onError);
+    this._player.removeEventListener('progress', this.onProgress);
+    this._player.removeEventListener('canplay', this.onCanPlay);
+    this._player.removeEventListener('play', this.onPlay);
+    this._player.removeEventListener('playing', this.onPlaying);
+    this._player.removeEventListener('pause', this.onPause);
+    this._player.removeEventListener('seeking', this.onSeeking);
+    this._player.removeEventListener('seeked', this.onSeeked);
+    this._player.removeEventListener('ended', this.onEnded);
+    this._player.removeEventListener('waiting', this.onWaiting);
+    this._player.removeEventListener('readystatechange', this.onReadyStateChanged);
+    this._player.removeEventListener('timeupdate', this.onTimeUpdate);
+    this._player.removeEventListener('durationchange', this.onDurationChange);
+    this._player.removeEventListener('ratechange', this.onPlaybackRateChange);
+    this._player.removeEventListener('segmentnotfound', this.onSegmentNotFound);
+    this._player.removeEventListener('volumechange', this.onVolumeChangeEvent);
+    this._player.presentation.removeEventListener('presentationmodechange', this.onPresentationModeChange);
+
+    this._player.textTracks.removeEventListener('addtrack', this.onAddTextTrack);
+    this._player.textTracks.removeEventListener('removetrack', this.onRemoveTextTrack);
+    this._player.textTracks.removeEventListener('change', this.onChangeTextTrack);
+
+    this._player.audioTracks.removeEventListener('addtrack', this.onAddAudioTrack);
+    this._player.audioTracks.removeEventListener('removetrack', this.onRemoveAudioTrack);
+    this._player.audioTracks.removeEventListener('change', this.onChangeAudioTrack);
+
+    this._player.videoTracks.removeEventListener('addtrack', this.onAddVideoTrack);
+    this._player.videoTracks.removeEventListener('removetrack', this.onRemoveVideoTrack);
+    this._player.videoTracks.removeEventListener('change', this.onChangeVideoTrack);
+
+    this._player.cast?.chromecast?.removeEventListener('statechange', this.onChromecastStateChange);
+    this._player.cast?.chromecast?.removeEventListener('error', this.onChromecastError);
+    this._player.cast?.airplay?.removeEventListener('statechange', this.onAirplayStateChange);
+
+    this._player.ads?.removeEventListener(FORWARDED_AD_EVENTS, this.onAdEvent);
+  }
+
+  private readonly onSourceChange = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.SOURCE_CHANGE));
+  };
+
+  private readonly onLoadStart = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.LOAD_START));
+  };
+
+  private readonly onLoadedData = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.LOADED_DATA));
+  };
+
+  private readonly onLoadedMetadata = () => {
+    this._facade.dispatchEvent(
+      new DefaultLoadedMetadataEvent(
+        this._player.textTracks.map((textTrack: NativeTextTrack) => fromNativeTextTrack(textTrack)),
+        this._player.audioTracks.map((audioTrack: NativeMediaTrack) => fromNativeMediaTrack(audioTrack)),
+        this._player.videoTracks.map((videoTrack: NativeMediaTrack) => fromNativeMediaTrack(videoTrack)),
+        1e3 * this._player.duration,
+        this._player.textTracks.find((track: NativeTextTrack) => track.mode === 'showing')?.uid,
+        this._player.videoTracks.find((track: NativeMediaTrack) => track.enabled)?.uid,
+        this._player.audioTracks.find((track: NativeMediaTrack) => track.enabled)?.uid,
+      ),
+    );
+  };
+
+  private readonly onError = (event: NativeErrorEvent) => {
+    this._facade.dispatchEvent(
+      new DefaultErrorEvent({
+        errorCode: event.errorObject.code.toString(),
+        errorMessage: event.errorObject.message,
+      }),
+    );
+  };
+
+  private readonly onProgress = () => {
+    this._facade.dispatchEvent(new DefaultProgressEvent(fromTimeRanges(this._player.seekable), fromTimeRanges(this._player.buffered)));
+  };
+
+  private readonly onCanPlay = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.CANPLAY));
+  };
+
+  private readonly onPlay = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.PLAY));
+  };
+
+  private readonly onPlaying = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.PLAYING));
+  };
+
+  private readonly onPause = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.PAUSE));
+  };
+
+  private readonly onSeeking = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.SEEKING));
+  };
+
+  private readonly onSeeked = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.SEEKED));
+  };
+
+  private readonly onEnded = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.ENDED));
+  };
+
+  private readonly onWaiting = () => {
+    this._facade.dispatchEvent(new BaseEvent(PlayerEventType.WAITING));
+  };
+
+  private readonly onReadyStateChanged = (event: NativeReadyStateChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultReadyStateChangeEvent(event.readyState));
+  };
+
+  private readonly onTimeUpdate = (event: NativeTimeUpdateEvent) => {
+    this._facade.dispatchEvent(new DefaultTimeupdateEvent(event.currentTime * 1e3, event.currentProgramDateTime?.getTime()));
+  };
+
+  private readonly onDurationChange = (event: NativeDurationChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultDurationChangeEvent(event.duration * 1e3));
+  };
+
+  private readonly onPlaybackRateChange = (event: NativeRateChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultRateChangeEvent(event.playbackRate));
+  };
+
+  private readonly onSegmentNotFound = () => {
+    this._facade.dispatchEvent(new DefaultSegmentNotFoundEvent(0, 'Segment not found', -1));
+  };
+
+  private readonly onVolumeChangeEvent = (event: NativeVolumeChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultVolumeChangeEvent(event.volume, this._player.muted));
+  };
+
+  private readonly onPresentationModeChange = (event: PresentationModeChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultPresentationModeChangeEvent(event.presentationMode as PresentationMode, PresentationMode.inline)); // TODO: move to extended event
+  };
+
+  private readonly onAddTextTrack = (event: AddTrackEvent) => {
+    const track = event.track as NativeTextTrack;
+    track.addEventListener('addcue', this.onAddTextTrackCue(track));
+    track.addEventListener('removecue', this.onRemoveTextTrackCue(track));
+    track.addEventListener('entercue', this.onEnterTextTrackCue(track));
+    track.addEventListener('exitcue', this.onExitTextTrackCue(track));
+    this._facade.dispatchEvent(new DefaultTextTrackListEvent(TrackListEventType.ADD_TRACK, track as TextTrack));
+  };
+
+  private readonly onRemoveTextTrack = (event: RemoveTrackEvent) => {
+    const track = event.track as NativeTextTrack;
+    track.removeEventListener('addcue', this.onAddTextTrackCue(track));
+    track.removeEventListener('removecue', this.onRemoveTextTrackCue(track));
+    track.removeEventListener('entercue', this.onEnterTextTrackCue(track));
+    track.removeEventListener('exitcue', this.onExitTextTrackCue(track));
+    this._facade.dispatchEvent(new DefaultTextTrackListEvent(TrackListEventType.REMOVE_TRACK, track as NativeTextTrack as TextTrack));
+  };
+
+  private readonly onChangeTextTrack = (event: TrackChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultTextTrackListEvent(TrackListEventType.CHANGE_TRACK, event.track as NativeTextTrack as TextTrack));
+  };
+
+  private readonly onAddAudioTrack = (event: AddTrackEvent) => {
+    this.onAddMediaTrack(event, MediaTrackType.AUDIO);
+  };
+
+  private readonly onAddVideoTrack = (event: AddTrackEvent) => {
+    this.onAddMediaTrack(event, MediaTrackType.VIDEO);
+  };
+
+  private readonly onAddMediaTrack = (event: AddTrackEvent, trackType: MediaTrackType) => {
+    const track = event.track as NativeMediaTrack;
+    track.addEventListener('activequalitychanged', this.onActiveQualityChanged(trackType, track));
+    this._facade.dispatchEvent(new DefaultMediaTrackListEvent(TrackListEventType.ADD_TRACK, trackType, track as MediaTrack));
+  };
+
+  private readonly onRemoveAudioTrack = (event: RemoveTrackEvent) => {
+    this.onRemoveMediaTrack(event, MediaTrackType.AUDIO);
+  };
+
+  private readonly onRemoveVideoTrack = (event: RemoveTrackEvent) => {
+    this.onRemoveMediaTrack(event, MediaTrackType.VIDEO);
+  };
+
+  private readonly onRemoveMediaTrack = (event: RemoveTrackEvent, trackType: MediaTrackType) => {
+    const track = event.track as NativeMediaTrack;
+    track.removeEventListener('activequalitychanged', this.onActiveQualityChanged(trackType, track));
+    this._facade.dispatchEvent(new DefaultMediaTrackListEvent(TrackListEventType.REMOVE_TRACK, trackType, track as MediaTrack));
+  };
+
+  private readonly onChangeAudioTrack = (event: TrackChangeEvent) => {
+    this.onChangeMediaTrack(event, MediaTrackType.AUDIO);
+  };
+
+  private readonly onChangeVideoTrack = (event: TrackChangeEvent) => {
+    this.onChangeMediaTrack(event, MediaTrackType.VIDEO);
+  };
+
+  private onChangeMediaTrack = (event: TrackChangeEvent, trackType: MediaTrackType) => {
+    const track = event.track as NativeMediaTrack;
+    this._facade.dispatchEvent(new DefaultMediaTrackListEvent(TrackListEventType.CHANGE_TRACK, trackType, track as MediaTrack));
+  };
+
+  private readonly onChromecastStateChange = (event: CastStateChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultChromecastChangeEvent(event.state as CastState));
+  };
+
+  private readonly onChromecastError = (event: ChromecastErrorEvent) => {
+    this._facade.dispatchEvent(new DefaultChromecastErrorEvent(event.error));
+  };
+
+  private readonly onAirplayStateChange = (event: CastStateChangeEvent) => {
+    this._facade.dispatchEvent(new DefaultAirplayStateChangeEvent(event.state as CastState));
+  };
+
+  private readonly onAdEvent = (event: NativeEvent) => {
+    const castedEvent = event as AdEvent;
+    this._facade.dispatchEvent(new DefaultAdEvent(event.type as AdEventType, castedEvent.ad));
+  };
+
+  private readonly onAddTextTrackCue = (track: NativeTextTrack) => (event: NativeEvent<'addcue'>) => {
+    const { cue } = event as unknown as { cue: NativeTextTrackCue };
+    if (cue) {
+      this._facade.dispatchEvent(new DefaultTextTrackEvent(TextTrackEventType.ADD_CUE, track.uid, fromNativeCue(cue)));
+    }
+  };
+
+  private readonly onRemoveTextTrackCue = (track: NativeTextTrack) => (event: NativeEvent<'removecue'>) => {
+    const { cue } = event as unknown as { cue: NativeTextTrackCue };
+    if (cue) {
+      this._facade.dispatchEvent(new DefaultTextTrackEvent(TextTrackEventType.REMOVE_CUE, track.uid, fromNativeCue(cue)));
+    }
+  };
+
+  private readonly onEnterTextTrackCue = (track: NativeTextTrack) => (event: NativeEvent<'entercue'>) => {
+    const { cue } = event as unknown as { cue: NativeTextTrackCue };
+    if (cue) {
+      this._facade.dispatchEvent(new DefaultTextTrackEvent(TextTrackEventType.ENTER_CUE, track.uid, fromNativeCue(cue)));
+    }
+  };
+
+  private readonly onExitTextTrackCue = (track: NativeTextTrack) => (event: NativeEvent<'exitcue'>) => {
+    const { cue } = event as unknown as { cue: NativeTextTrackCue };
+    if (cue) {
+      this._facade.dispatchEvent(new DefaultTextTrackEvent(TextTrackEventType.EXIT_CUE, track.uid, fromNativeCue(cue)));
+    }
+  };
+
+  private readonly onActiveQualityChanged = (trackType: MediaTrackType, track: NativeMediaTrack) => () => {
+    const quality = track.activeQuality;
+    this._facade.dispatchEvent(
+      new DefaultMediaTrackEvent(MediaTrackEventType.ACTIVE_QUALITY_CHANGED, trackType, track.uid, quality ? [quality] : undefined),
+    );
+  };
+}
+
+const FORWARDED_AD_EVENTS: Array<AdEventType> = [
+  AdEventType.ADD_AD_BREAK,
+  AdEventType.REMOVE_AD_BREAK,
+  AdEventType.AD_LOADED,
+  AdEventType.AD_BREAK_BEGIN,
+  AdEventType.AD_BREAK_END,
+  AdEventType.AD_BREAK_CHANGE,
+  AdEventType.UPDATE_AD_BREAK,
+  AdEventType.ADD_AD,
+  AdEventType.AD_BEGIN,
+  AdEventType.AD_END,
+  AdEventType.UPDATE_AD,
+  AdEventType.AD_FIRST_QUARTILE,
+  AdEventType.AD_MIDPOINT,
+  AdEventType.AD_THIRD_QUARTILE,
+  AdEventType.AD_SKIP,
+  AdEventType.AD_IMPRESSION,
+  AdEventType.AD_ERROR,
+  AdEventType.AD_METADATA,
+  AdEventType.AD_BUFFERING,
+];
+
+function fromTimeRanges(timeRanges: TimeRanges): TimeRange[] {
+  const result: TimeRange[] = [];
+  for (let i = 0; i < timeRanges.length; i++) {
+    result.push({
+      start: timeRanges.start(i) * 1e3,
+      end: timeRanges.end(i) * 1e3,
+    });
+  }
+  return result;
+}