bitmovin-player-react-native 0.44.1-alpha.0 → 1.0.0-alpha.0

package/src/events.ts

@@ -48,38 +48,44 @@ export interface ErrorEvent extends Event {
  * Emitted when a source is loaded into the player.
  * Seeking and time shifting are allowed as soon as this event is seen.
  */
-export interface PlayerActiveEvent extends Event {}
+export type PlayerActiveEvent = Event;
+
+/**
+ * Emitted when a source is unloaded from the player.
+ * Seeking and time shifting are not allowed anymore after this event.
+ */
+export type PlayerInactiveEvent = Event;
 
 /**
  * Emitted when a player error occurred.
  */
-export interface PlayerErrorEvent extends ErrorEvent {}
+export type PlayerErrorEvent = ErrorEvent;
 
 /**
  * Emitted when a player warning occurred.
  */
-export interface PlayerWarningEvent extends ErrorEvent {}
+export type PlayerWarningEvent = ErrorEvent;
 
 /**
  * Emitted when the player is destroyed.
  */
-export interface DestroyEvent extends Event {}
+export type DestroyEvent = Event;
 
 /**
  * Emitted when the player is muted.
  */
-export interface MutedEvent extends Event {}
+export type MutedEvent = Event;
 
 /**
  * Emitted when the player is unmuted.
  */
-export interface UnmutedEvent extends Event {}
+export type UnmutedEvent = Event;
 
 /**
  * Emitted when the player is ready for immediate playback, because initial audio/video
  * has been downloaded.
  */
-export interface ReadyEvent extends Event {}
+export type ReadyEvent = Event;
 
 /**
  * Emitted when the player is paused.
@@ -114,7 +120,7 @@ export interface PlayingEvent extends Event {
 /**
  * Emitted when the playback of the current media has finished.
  */
-export interface PlaybackFinishedEvent extends Event {}
+export type PlaybackFinishedEvent = Event;
 
 /**
  * Source object representation the way it appears on event's payloads such as `SeekEvent`, for example.
@@ -182,7 +188,7 @@ export interface SeekEvent extends Event {
  * This event only applies to VoD streams.
  * When looking for an equivalent for live streams, the {@link TimeShiftedEvent} is relevant.
  */
-export interface SeekedEvent extends Event {}
+export type SeekedEvent = Event;
 
 /**
  * Emitted when the player starts time shifting.
@@ -205,17 +211,17 @@ export interface TimeShiftEvent extends Event {
  * This event only applies to live streams.
  * When looking for an equivalent for VoD streams, the {@link SeekedEvent} is relevant.
  */
-export interface TimeShiftedEvent extends Event {}
+export type TimeShiftedEvent = Event;
 
 /**
  * Emitted when the player begins to stall and to buffer due to an empty buffer.
  */
-export interface StallStartedEvent extends Event {}
+export type StallStartedEvent = Event;
 
 /**
  * Emitted when the player ends stalling, due to enough data in the buffer.
  */
-export interface StallEndedEvent extends Event {}
+export type StallEndedEvent = Event;
 
 /**
  * Emitted when the current playback time has changed.
@@ -262,12 +268,12 @@ export interface SourceUnloadedEvent extends Event {
 /**
  * Emitted when a source error occurred.
  */
-export interface SourceErrorEvent extends ErrorEvent {}
+export type SourceErrorEvent = ErrorEvent;
 
 /**
  * Emitted when a source warning occurred.
  */
-export interface SourceWarningEvent extends ErrorEvent {}
+export type SourceWarningEvent = ErrorEvent;
 
 /**
  * Emitted when a new audio track is added to the player.
@@ -340,63 +346,63 @@ export interface SubtitleChangedEvent extends Event {
 /**
  * Emitted when the player enters Picture in Picture mode.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface PictureInPictureEnterEvent extends Event {}
+export type PictureInPictureEnterEvent = Event;
 
 /**
  * Emitted when the player exits Picture in Picture mode.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface PictureInPictureExitEvent extends Event {}
+export type PictureInPictureExitEvent = Event;
 
 /**
  * Emitted when the player has finished entering Picture in Picture mode on iOS.
  *
- * @platform iOS
+ * @remarks Platform: iOS
  */
-export interface PictureInPictureEnteredEvent extends Event {}
+export type PictureInPictureEnteredEvent = Event;
 
 /**
  * Emitted when the player has finished exiting Picture in Picture mode on iOS.
  *
- * @platform iOS
+ * @remarks Platform: iOS
  */
-export interface PictureInPictureExitedEvent extends Event {}
+export type PictureInPictureExitedEvent = Event;
 
 /**
  * Emitted when the fullscreen functionality has been enabled.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface FullscreenEnabledEvent extends Event {}
+export type FullscreenEnabledEvent = Event;
 
 /**
  * Emitted when the fullscreen functionality has been disabled.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface FullscreenDisabledEvent extends Event {}
+export type FullscreenDisabledEvent = Event;
 
 /**
  * Emitted when the player enters fullscreen mode.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface FullscreenEnterEvent extends Event {}
+export type FullscreenEnterEvent = Event;
 
 /**
  * Emitted when the player exits fullscreen mode.
  *
- * @platform iOS, Android
+ * @remarks Platform: iOS, Android
  */
-export interface FullscreenExitEvent extends Event {}
+export type FullscreenExitEvent = Event;
 
 /**
  * Emitted when the availability of the Picture in Picture mode changed on Android.
  *
- * @platform Android
+ * @remarks Platform: Android
  */
 export interface PictureInPictureAvailabilityChangedEvent extends Event {
   /**
@@ -590,28 +596,28 @@ export interface VideoPlaybackQualityChangedEvent extends Event {
 /**
  * Emitted when casting to a cast-compatible device is available.
  */
-export interface CastAvailableEvent extends Event {}
+export type CastAvailableEvent = Event;
 
 /**
  * Emitted when the playback on a cast-compatible device was paused.
  *
  * On Android {@link PausedEvent} is also emitted while casting.
  */
-export interface CastPausedEvent extends Event {}
+export type CastPausedEvent = Event;
 
 /**
  * Emitted when the playback on a cast-compatible device has finished.
  *
  * On Android {@link PlaybackFinishedEvent} is also emitted while casting.
  */
-export interface CastPlaybackFinishedEvent extends Event {}
+export type CastPlaybackFinishedEvent = Event;
 
 /**
  * Emitted when playback on a cast-compatible device has started.
  *
  * On Android {@link PlayingEvent} is also emitted while casting.
  */
-export interface CastPlayingEvent extends Event {}
+export type CastPlayingEvent = Event;
 
 /**
  * Emitted when the cast app is launched successfully.
@@ -626,17 +632,17 @@ export interface CastStartedEvent extends Event {
 /**
  * Emitted when casting is initiated, but the user still needs to choose which device should be used.
  */
-export interface CastStartEvent extends Event {}
+export type CastStartEvent = Event;
 
 /**
  * Emitted when casting to a cast-compatible device is stopped.
  */
-export interface CastStoppedEvent extends Event {}
+export type CastStoppedEvent = Event;
 
 /**
  * Emitted when the time update from the currently used cast-compatible device is received.
  */
-export interface CastTimeUpdatedEvent extends Event {}
+export type CastTimeUpdatedEvent = Event;
 
 /**
  * Contains information for the {@link CastWaitingForDeviceEvent}.
@@ -691,7 +697,7 @@ export interface DownloadFinishedEvent extends Event {
   /**
    * The last redirect location, or `null` if no redirect happened.
    */
-  lastRedirectLocation?: String;
+  lastRedirectLocation?: string;
   /**
    * The size of the downloaded data, in bytes.
    */
@@ -699,12 +705,12 @@ export interface DownloadFinishedEvent extends Event {
   /**
    * The URL of the request.
    */
-  url: String;
+  url: string;
 }
 
 /**
  * Emitted when the player transitions from one playback speed to another.
- * @platform iOS, tvOS
+ * @remarks Platform: iOS, tvOS
  */
 export interface PlaybackSpeedChangedEvent extends Event {
   /**

package/src/hooks/useProxy.ts

@@ -1,7 +1,6 @@
-import omit from 'lodash.omit';
-import { useCallback, RefObject } from 'react';
-import { NativeSyntheticEvent, findNodeHandle } from 'react-native';
+import { RefObject, useCallback } from 'react';
 import { Event } from '../events';
+import { findNodeHandle } from 'react-native';
 
 /**
  * A function that takes a generic event as argument.
@@ -11,30 +10,24 @@ type Callback<E> = (event: E) => void;
 /**
  * A function that takes the synthetic version of a generic event as argument.
  */
-type NativeCallback<E> = (nativeEvent: NativeSyntheticEvent<E>) => void;
+type NativeCallback<E> = (event: { nativeEvent: E }) => void;
 
 /**
- * Returns the actual event payload without RN's bubbling data.
- */
-function unwrapNativeEvent<E extends Event>(event: NativeSyntheticEvent<E>): E {
-  return omit(event.nativeEvent, ['target']) as E;
-}
-
-/**
- * Produce a callback function that takes some native synthetic event and calls
- * the passed callback with the unwrapped event value. And always check first
- * if the received synthetic event target matches viewRef's node value.
+ * Create a proxy function that unwraps native events.
  */
 export function useProxy(
   viewRef: RefObject<any>
 ): <E extends Event>(callback?: Callback<E>) => NativeCallback<E> {
   return useCallback(
-    (callback) => (event) => {
-      const node: number = (event.target as any)._nativeTag;
-      if (node === findNodeHandle(viewRef.current)) {
-        callback?.(unwrapNativeEvent(event));
-      }
-    },
+    <E extends Event>(callback?: Callback<E>) =>
+      (event: { nativeEvent: E }) => {
+        const eventTargetNodeHandle: number = (event.nativeEvent as any).target;
+        if (eventTargetNodeHandle !== findNodeHandle(viewRef.current)) {
+          return;
+        }
+        const { target, ...eventWithoutTarget } = event.nativeEvent as any;
+        callback?.(eventWithoutTarget as E);
+      },
     [viewRef]
   );
 }

package/src/mediaControlConfig.ts

@@ -13,7 +13,7 @@ export interface MediaControlConfig {
    * For a detailed list of the supported features in the **default behavior**,
    * check the **Default Supported Features** section.
    *
-   * @note Enabling this flag will automatically treat {@link TweaksConfig.updatesNowPlayingInfoCenter} as `false`.
+   * @remarks Enabling this flag will automatically treat {@link TweaksConfig.updatesNowPlayingInfoCenter} as `false`.
    *
    * ## Limitations
    * ---

package/src/modules/AudioSessionModule.ts

@@ -0,0 +1,13 @@
+import { NativeModule, requireNativeModule } from 'expo-modules-core';
+import { Platform } from 'react-native';
+
+export type AudioSessionModuleEvents = Record<string, any>;
+
+declare class AudioSessionModule extends NativeModule<AudioSessionModuleEvents> {
+  setCategory(category: string): Promise<void>;
+}
+
+// iOS-only module
+export default Platform.OS === 'ios'
+  ? requireNativeModule<AudioSessionModule>('AudioSessionModule')
+  : null;

package/src/modules/BitmovinCastManagerModule.ts

@@ -0,0 +1,14 @@
+import { NativeModule, requireNativeModule } from 'expo-modules-core';
+
+export type BitmovinCastManagerModuleEvents = Record<string, any>;
+
+declare class BitmovinCastManagerModule extends NativeModule<BitmovinCastManagerModuleEvents> {
+  isInitialized(): Promise<boolean>;
+  initializeCastManager(options?: Record<string, any>): Promise<void>;
+  sendMessage(message: string, messageNamespace?: string): Promise<void>;
+  updateContext?(): Promise<void>; // Android only
+}
+
+export default requireNativeModule<BitmovinCastManagerModule>(
+  'BitmovinCastManagerModule'
+);

package/src/modules/BufferModule.ts

@@ -0,0 +1,18 @@
+import { NativeModule, requireNativeModule } from 'expo-modules-core';
+import { BufferLevels } from '../bufferApi';
+
+export type BufferModuleEvents = Record<string, any>;
+
+declare class BufferModule extends NativeModule<BufferModuleEvents> {
+  /**
+   * Get buffer level for the specified player and buffer type.
+   */
+  getLevel(playerId: string, type: string): Promise<BufferLevels>;
+
+  /**
+   * Set target level for the specified player and buffer type.
+   */
+  setTargetLevel(playerId: string, type: string, value: number): Promise<void>;
+}
+
+export default requireNativeModule<BufferModule>('BufferModule');

package/src/modules/DebugModule.ts

@@ -0,0 +1,9 @@
+import { NativeModule, requireNativeModule } from 'expo-modules-core';
+
+export type DebugModuleEvents = Record<string, any>;
+
+declare class DebugModule extends NativeModule<DebugModuleEvents> {
+  setDebugLoggingEnabled(enabled: boolean): Promise<void>;
+}
+
+export default requireNativeModule<DebugModule>('DebugModule');

package/src/modules/PlayerModule.ts

@@ -0,0 +1,251 @@
+import { NativeModule, requireNativeModule } from 'expo-modules-core';
+
+export type PlayerModuleEvents = Record<string, any>;
+
+declare class PlayerModule extends NativeModule<PlayerModuleEvents> {
+  /**
+   * Call .play() on nativeId's player.
+   */
+  play(nativeId: string): Promise<void>;
+
+  /**
+   * Call .pause() on nativeId's player.
+   */
+  pause(nativeId: string): Promise<void>;
+
+  /**
+   * Call .mute() on nativeId's player.
+   */
+  mute(nativeId: string): Promise<void>;
+
+  /**
+   * Call .unmute() on nativeId's player.
+   */
+  unmute(nativeId: string): Promise<void>;
+
+  /**
+   * Call .seek(time) on nativeId's player.
+   */
+  seek(nativeId: string, time: number): Promise<void>;
+
+  /**
+   * Sets timeShift on nativeId's player.
+   */
+  timeShift(nativeId: string, offset: number): Promise<void>;
+
+  /**
+   * Call .destroy() on nativeId's player and remove from registry.
+   */
+  destroy(nativeId: string): Promise<void>;
+
+  /**
+   * Call .setVolume(volume) on nativeId's player.
+   */
+  setVolume(nativeId: string, volume: number): Promise<void>;
+
+  /**
+   * Resolve nativeId's current volume.
+   */
+  getVolume(nativeId: string): Promise<number | null>;
+
+  /**
+   * Resolve nativeId's current time.
+   */
+  currentTime(nativeId: string, mode?: string): Promise<number | null>;
+
+  /**
+   * Resolve nativeId's current playing state.
+   */
+  isPlaying(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's current paused state.
+   */
+  isPaused(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's active source duration.
+   */
+  duration(nativeId: string): Promise<number | null>;
+
+  /**
+   * Resolve nativeId's current muted state.
+   */
+  isMuted(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Call .unload() on nativeId's player.
+   */
+  unload(nativeId: string): Promise<void>;
+
+  /**
+   * Resolve nativeId's current time shift value.
+   */
+  getTimeShift(nativeId: string): Promise<number | null>;
+
+  /**
+   * Resolve nativeId's live stream state.
+   */
+  isLive(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's maximum time shift value.
+   */
+  getMaxTimeShift(nativeId: string): Promise<number | null>;
+
+  /**
+   * Resolve nativeId's current playback speed.
+   */
+  getPlaybackSpeed(nativeId: string): Promise<number | null>;
+
+  /**
+   * Set playback speed for nativeId's player.
+   */
+  setPlaybackSpeed(nativeId: string, playbackSpeed: number): Promise<void>;
+
+  /**
+   * Resolve nativeId's current ad state.
+   */
+  isAd(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Set maximum selectable bitrate for nativeId's player.
+   */
+  setMaxSelectableBitrate(nativeId: string, maxBitrate: number): Promise<void>;
+
+  /**
+   * Resolve nativeId's AirPlay activation state (iOS only).
+   */
+  isAirPlayActive(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's AirPlay availability state (iOS only).
+   */
+  isAirPlayAvailable(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's cast availability state.
+   */
+  isCastAvailable(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Resolve nativeId's current casting state.
+   */
+  isCasting(nativeId: string): Promise<boolean | null>;
+
+  /**
+   * Initiate casting for nativeId's player.
+   */
+  castVideo(nativeId: string): Promise<void>;
+
+  /**
+   * Stop casting for nativeId's player.
+   */
+  castStop(nativeId: string): Promise<void>;
+
+  /**
+   * Skip current ad for nativeId's player.
+   */
+  skipAd(nativeId: string): Promise<void>;
+
+  /**
+   * Check if player can play at specified playback speed (iOS only).
+   */
+  canPlayAtPlaybackSpeed(
+    nativeId: string,
+    playbackSpeed: number
+  ): Promise<boolean | null>;
+
+  /**
+   * Creates a new Player instance using the provided config.
+   */
+  initializeWithConfig(
+    nativeId: string,
+    config?: Record<string, any>,
+    networkNativeId?: string,
+    decoderNativeId?: string
+  ): Promise<void>;
+
+  /**
+   * Creates a new analytics-enabled Player instance.
+   */
+  initializeWithAnalyticsConfig(
+    nativeId: string,
+    analyticsConfig: Record<string, any>,
+    config?: Record<string, any>,
+    networkNativeId?: string,
+    decoderNativeId?: string
+  ): Promise<void>;
+
+  /**
+   * Load source into the player.
+   * Requires SourceModule dependency.
+   */
+  loadSource(nativeId: string, sourceNativeId: string): Promise<void>;
+
+  /**
+   * Load offline content into the player.
+   */
+  loadOfflineContent(
+    nativeId: string,
+    offlineContentId: string,
+    options?: Record<string, any>
+  ): Promise<void>;
+
+  /**
+   * Get current audio track.
+   */
+  getAudioTrack(nativeId: string): Promise<any | null>;
+
+  /**
+   * Get available audio tracks.
+   */
+  getAvailableAudioTracks(nativeId: string): Promise<any[]>;
+
+  /**
+   * Set audio track.
+   */
+  setAudioTrack(nativeId: string, trackId: string): Promise<void>;
+
+  /**
+   * Get current subtitle track.
+   */
+  getSubtitleTrack(nativeId: string): Promise<any | null>;
+
+  /**
+   * Get available subtitle tracks.
+   */
+  getAvailableSubtitles(nativeId: string): Promise<any[]>;
+
+  /**
+   * Set subtitle track.
+   */
+  setSubtitleTrack(nativeId: string, trackId: string): Promise<void>;
+
+  /**
+   * Schedule an ad.
+   */
+  scheduleAd(nativeId: string, adConfig: Record<string, any>): Promise<void>;
+
+  /**
+   * Get thumbnail for time position.
+   */
+  getThumbnail(nativeId: string, time: number): Promise<any | null>;
+
+  /**
+   * Get current video quality.
+   */
+  getVideoQuality(nativeId: string): Promise<any | null>;
+
+  /**
+   * Get available video qualities.
+   */
+  getAvailableVideoQualities(nativeId: string): Promise<any[]>;
+
+  /**
+   * Set video quality.
+   */
+  setVideoQuality(nativeId: string, qualityId: string): Promise<void>;
+}
+
+export default requireNativeModule<PlayerModule>('PlayerModule');