@pigeonmal/react-native-video 7.0.0-beta.10

package/src/core/types/VideoInformation.ts

@@ -0,0 +1,44 @@
+import type { VideoOrientation } from './VideoOrientation';
+
+export interface VideoInformation {
+  /**
+   * The bitrate of the video in kbps.
+   */
+  bitrate: number;
+
+  /**
+   * The width of the video in pixels.
+   */
+  width: number;
+
+  /**
+   * The height of the video in pixels.
+   */
+  height: number;
+
+  /**
+   * The duration of the video in seconds.
+   */
+  duration: bigint;
+
+  /**
+   * The file size of the video in bytes.
+   */
+  fileSize: bigint;
+
+  /**
+   * Whether the video is HDR.
+   */
+  isHDR: boolean;
+
+  /**
+   * Whether the video is live
+   */
+  isLive: boolean;
+
+  /**
+   * The orientation of the video.
+   * see {@link VideoOrientation}
+   */
+  orientation: VideoOrientation;
+}

package/src/core/types/VideoOrientation.ts

@@ -0,0 +1,8 @@
+export type VideoOrientation =
+  | 'portrait'
+  | 'landscape'
+  | 'portrait-upside-down'
+  | 'landscape-left'
+  | 'landscape-right'
+  | 'square'
+  | 'unknown';

package/src/core/types/VideoPlayerBase.ts

@@ -0,0 +1,224 @@
+import type { IgnoreSilentSwitchMode } from './IgnoreSilentSwitchMode';
+import type { MixAudioMode } from './MixAudioMode';
+import type { VideoPlayerSourceBase } from './VideoPlayerSourceBase';
+import type { VideoPlayerStatus } from './VideoPlayerStatus';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { VideoConfig } from './VideoConfig';
+import type { AllPlayerTracks, PlayerTrack, TrackType } from './PlayerTrack';
+
+export interface VideoPlayerBase {
+  /**
+   * The source of the video.
+   * Source is immutable. To change the source, you need to call {@link replaceSourceAsync} method.
+   * see {@link VideoPlayerSourceBase}
+   */
+  readonly source: VideoPlayerSourceBase;
+
+  /**
+   * The status of the player.
+   * @param idle - The player is idle (source is not loaded)
+   * @param loading - The player is loading.
+   * @param readyToPlay - The player is ready to play (source is loaded).
+   * @param error - The player has an error.
+   */
+  readonly status: VideoPlayerStatus;
+
+  /**
+   * The current time of the video in seconds (1.0 = 1 sec).
+   * Returns NaN if the current time is not available.
+   */
+  readonly duration: number;
+
+  /**
+   * The volume of the video (0.0 = 0%, 1.0 = 100%).
+   * @note If the player is {@link muted}, the volume will be 0.0.
+   */
+  volume: number;
+
+  /**
+   * The duration of the video in seconds (1.0 = 1 sec).
+   * Returns NaN if the duration is not available.
+   */
+  currentTime: number;
+
+  /**
+   * Modify the progress event interval (ms)
+   * By default it's 250ms
+   */
+  progressEventInterval: number;
+
+  /**
+   * Subtitle delay (milliseconds) negative or positive number
+   */
+  subtitleDelay: bigint;
+
+  /**
+   * Whether the player is muted.
+   */
+  muted: boolean;
+
+  /**
+   * Whether the player is looped.
+   */
+  loop: boolean;
+
+  /**
+   * Controls the speed at which the player should play.
+   * @note if rate is = 0, it will pause video.
+   */
+  rate: number;
+
+  /**
+   * Controls the audio mixing mode of the player.
+   *
+   * - `mixWithOthers` - Mix with other players.
+   * - `doNotMix` - Do not mix with other players.
+   * - `duckOthers` - Duck other players.
+   * - `auto` - uses default behavior for player.
+   *
+   * default is `auto`.
+   */
+  mixAudioMode: MixAudioMode;
+
+  /**
+   * Controls the silent switch mode of the player.
+   * @note This is only supported on iOS.
+   *
+   * - `auto` - uses default behavior for player.
+   * - `ignore` - ignore the silent switch.
+   * - `obey` - obey the silent switch.
+   */
+  ignoreSilentSwitchMode: IgnoreSilentSwitchMode;
+
+  /**
+   * Whether the player should play in background.
+   *
+   * - `true` - play in background.
+   * - `false` - pause in background (default).
+   *
+   * @note this can override {@link playWhenInactive}.
+   */
+  playInBackground: boolean;
+
+  /**
+   * Whether the player should play when the app is inactive (user opened control center).
+   *
+   * - `true` - play when the app is inactive.
+   * - `false` - pause when the app is inactive (default).
+   *
+   * @note this can be overridden by {@link playInBackground}.
+   * @note This is only supported on iOS.
+   */
+  playWhenInactive: boolean;
+
+  /**
+   * Whether the player is playing.
+   * @note This is a read-only property.
+   * @note To pause/resume the player, you need to use {@link play} and {@link pause} methods.
+   */
+  readonly isPlaying: boolean;
+
+  /**
+   * Manually initialize the player. You don't need to call this method manually, unless you set `initializeOnCreation` to false in {@link VideoConfig}
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Preload the video.
+   * This is useful to avoid delay when the user plays the video.
+   * Preloading too many videos can lead to memory issues or performance issues.
+   */
+  preload(): Promise<void>;
+
+  /**
+   * Start playback of player.
+   */
+  play(): void;
+
+  /**
+   * Pause playback of player.
+   */
+  pause(): void;
+
+  /**
+   * Seek by given time.
+   * If the time is negative, it will seek backward.
+   * time will be clamped if it is out of range (0 ~ {@link duration}).
+   * @param time - The time to seek from current time in seconds.
+   */
+  seekBy(time: number): void;
+
+  /**
+   * Seek to a specific time in the video.
+   * @param time - The time to seek to in seconds.
+   * @note This have same effect as {@link currentTime} setter.
+   * @note time will be clamped if it is out of range (0 ~ {@link duration}).
+   */
+  seekTo(time: number): void;
+
+  /**
+   * Replace the current source of the player.
+   * @param source - The new source of the video.
+   * @note If you want to clear the source, you can pass null. It has the same effect as {@link release}.
+   * see {@link VideoPlayerSourceBase}
+   */
+  replaceSourceAsync(source: VideoPlayerSourceBase | null): Promise<void>;
+
+  /**
+   * Get all available text tracks for the current source.
+   * @returns Array of available text tracks
+   */
+  getAvailableTextTracks(): PlayerTrack[];
+
+  /**
+   * Get all tracks (audios, videos, texts) tracks for the current source.
+   * @returns All tracks of the player
+   */
+  getAllPlayerTracks(): AllPlayerTracks;
+
+  /**
+   * Select a track (text, audio, video) to display.
+   * @param type - TrackType (text, audio, video)
+   * @param id - The id of the track to select.
+   */
+  selectTrackById(type: TrackType, id?: string): void;
+
+  /**
+   * Select a track (text, audio, video) to display.
+   * @param type - TrackType (text, audio, video)
+   * @param index - The index of the track to select.
+   */
+  selectTrackByIndex(type: TrackType, index?: number): void;
+
+  /**
+   * Stops playback and clears all media items so the Player can be safely reused.
+   *
+   * This function:
+   * - Stops playback if currently playing or buffering
+   * - Cancels any ongoing loading
+   * - Clears the playlist/timeline
+   * - Keeps the Player instance and its resources alive
+   *
+   * After calling this function, the Player will be in [Player.STATE_IDLE]
+   * with an empty playlist.
+   *
+   * Use this when:
+   * - Reusing a single Player instance for multiple media items
+   * - Switching videos frequently (e.g. feeds, previews, RecyclerView)
+   *
+   * Do NOT use this when you are done with playback permanently.
+   * In that case, call [Player.release] instead.
+   */
+  resetForReuse(): void;
+  /**
+   * Get the currently selected text track.
+   * @returns The currently selected text track, or undefined if none is selected
+   */
+  readonly selectedTrack?: PlayerTrack;
+
+  /**
+   * Releases the player's native resources and releases native state.
+   */
+  release(): void;
+}

package/src/core/types/VideoPlayerSourceBase.ts

@@ -0,0 +1,19 @@
+import type { NativeVideoConfig } from './VideoConfig';
+import type { VideoInformation } from './VideoInformation';
+
+export interface VideoPlayerSourceBase {
+  /**
+   * The URI of the asset.
+   */
+  readonly uri: string;
+
+  /**
+   * The config of the asset.
+   */
+  readonly config: NativeVideoConfig;
+
+  /**
+   * Get the information about the asset.
+   */
+  getAssetInformationAsync(): Promise<VideoInformation>;
+}

package/src/core/types/VideoPlayerStatus.ts

@@ -0,0 +1,8 @@
+/**
+ * The status of the player.
+ * @param idle - The player is idle (source is not loaded)
+ * @param loading - The player is loading (source is loading).
+ * @param readyToPlay - The player is ready to play (source is loaded).
+ * @param error - The player has an error (source is not loaded).
+ */
+export type VideoPlayerStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';

package/src/core/utils/playerFactory.ts

@@ -0,0 +1,35 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type {
+  VideoPlayer,
+  VideoPlayerFactory,
+} from '../../spec/nitro/VideoPlayer.nitro';
+import type { VideoPlayerSource } from '../../spec/nitro/VideoPlayerSource.nitro';
+import type { VideoConfig, VideoSource } from '../types/VideoConfig';
+import { createSource, isVideoPlayerSource } from './sourceFactory';
+import { tryParseNativeVideoError } from '../types/VideoError';
+
+const VideoPlayerFactory =
+  NitroModules.createHybridObject<VideoPlayerFactory>('VideoPlayerFactory');
+
+/**
+ * @internal
+ * Creates a Native VideoPlayer instance.
+ *
+ * @param source - The source of the video to play
+ * @returns The Native VideoPlayer instance
+ */
+export const createPlayer = (
+  source?: VideoSource | VideoConfig | VideoPlayerSource
+): VideoPlayer => {
+  try {
+    return VideoPlayerFactory.createPlayer(
+      source == null
+        ? undefined
+        : isVideoPlayerSource(source)
+          ? source
+          : createSource(source)
+    );
+  } catch (error) {
+    throw tryParseNativeVideoError(error);
+  }
+};

package/src/core/utils/sourceFactory.ts

@@ -0,0 +1,171 @@
+import { Image, Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import type {
+  VideoPlayerSource,
+  VideoPlayerSourceFactory,
+} from '../../spec/nitro/VideoPlayerSource.nitro';
+import type {
+  ExternalSubtitle,
+  NativeVideoConfig,
+  SubtitleType,
+  VideoConfig,
+  VideoSource,
+} from '../types/VideoConfig';
+import {
+  tryParseNativeVideoError,
+  VideoRuntimeError,
+} from '../types/VideoError';
+
+const VideoPlayerSourceFactory =
+  NitroModules.createHybridObject<VideoPlayerSourceFactory>(
+    'VideoPlayerSourceFactory'
+  );
+
+export const isVideoPlayerSource = (obj: any): obj is VideoPlayerSource => {
+  return (
+    obj && // obj is not null
+    typeof obj === 'object' && // obj is an object
+    'name' in obj && // obj has a name property
+    obj.name === 'VideoPlayerSource' // obj.name is 'VideoPlayerSource'
+  );
+};
+
+/**
+ * Creates a `VideoPlayerSource` instance from a URI (string).
+ *
+ * @param uri - The URI of the video to play
+ * @returns The `VideoPlayerSource` instance
+ */
+export const createSourceFromUri = (uri: string) => {
+  if (!uri || typeof uri !== 'string') {
+    throw new Error('RNV: Invalid source. The URI must be a non-empty string.');
+  }
+
+  try {
+    return VideoPlayerSourceFactory.fromUri(uri);
+  } catch (error) {
+    throw tryParseNativeVideoError(error);
+  }
+};
+
+/**
+ * Creates a `VideoPlayerSource` instance from a `VideoConfig`.
+ *
+ * @note The `uri` property is required to be a string.
+ *
+ * @param config - The `VideoConfig` to create the `VideoPlayerSource` from
+ * @returns The `VideoPlayerSource` instance
+ */
+export const createSourceFromVideoConfig = (
+  config: VideoConfig & { uri: string }
+) => {
+  if (!config.uri || typeof config.uri !== 'string') {
+    throw new VideoRuntimeError('source/invalid-uri', 'Invalid source URI');
+  }
+
+  if (config.externalSubtitles) {
+    config.externalSubtitles = parseExternalSubtitles(config.externalSubtitles);
+  }
+
+  // Ensure platform-based default for DRM type if DRM is provided without a type
+  if (config.drm && config.drm.type === undefined) {
+    const defaultDrmType = Platform.select({
+      android: 'widevine',
+      ios: 'fairplay',
+      default: undefined,
+    });
+
+    if (defaultDrmType) {
+      config.drm = {
+        ...config.drm,
+        type: defaultDrmType,
+      };
+    }
+  }
+
+  // Set default value for initializeOnCreation (true)
+  if (config.initializeOnCreation === undefined) {
+    config.initializeOnCreation = true;
+  }
+
+  try {
+    return VideoPlayerSourceFactory.fromVideoConfig(
+      config as NativeVideoConfig
+    );
+  } catch (error) {
+    throw tryParseNativeVideoError(error);
+  }
+};
+
+/**
+ * Parses the external subtitles from the `ExternalSubtitle` to the `NativeExternalSubtitle` format.
+ *
+ * @param externalSubtitles - The external subtitles to parse
+ * @returns The parsed external subtitles
+ */
+const parseExternalSubtitles = (
+  externalSubtitles: ExternalSubtitle[]
+): NativeVideoConfig['externalSubtitles'] => {
+  return externalSubtitles.map((subtitle) => ({
+    uri: subtitle.uri,
+    label: subtitle.label,
+    type: (subtitle.type ?? 'auto') as SubtitleType,
+    language: subtitle.language ?? 'und',
+  }));
+};
+
+/**
+ * Creates a `VideoPlayerSource`
+ *
+ * @param source - The `VideoSource` to create the `VideoPlayerSource` from
+ * @returns The `VideoPlayerSource` instance
+ */
+export const createSource = (
+  source: VideoSource | VideoConfig | VideoPlayerSource
+): VideoPlayerSource => {
+  // If source is a VideoPlayerSource, we can directly return it
+  if (isVideoPlayerSource(source)) {
+    return source;
+  }
+
+  // If source is a string, we can directly create the player
+  if (typeof source === 'string') {
+    return createSourceFromUri(source);
+  }
+
+  // If source is a number (asset), we need to resolve the asset source and create the player
+  if (typeof source === 'number') {
+    const resolvedSource = Image.resolveAssetSource(source);
+    if (!resolvedSource?.uri || typeof resolvedSource.uri !== 'string') {
+      throw new VideoRuntimeError('source/invalid-uri', 'Invalid source URI');
+    }
+    return createSourceFromUri(resolvedSource.uri);
+  }
+
+  // If source is an object (VideoConfig)
+  if (typeof source === 'object' && source !== null && 'uri' in source) {
+    if (typeof source.uri === 'string') {
+      return createSourceFromVideoConfig(
+        source as VideoConfig & { uri: string }
+      );
+    }
+
+    if (typeof source.uri === 'number') {
+      const resolvedSource = Image.resolveAssetSource(source.uri);
+      if (!resolvedSource?.uri || typeof resolvedSource.uri !== 'string') {
+        throw new VideoRuntimeError('source/invalid-uri', 'Invalid source URI');
+      }
+
+      const config = {
+        ...source,
+        uri: resolvedSource.uri,
+      };
+
+      return createSourceFromVideoConfig(config);
+    }
+
+    throw new VideoRuntimeError('source/invalid-uri', 'Invalid source URI');
+  }
+
+  throw new VideoRuntimeError('player/invalid-source', 'Invalid source');
+};

package/src/core/video-view/NativeVideoView.tsx

@@ -0,0 +1,18 @@
+import { Platform, UIManager } from 'react-native';
+
+import VideoViewNativeComponent from '../../spec/fabric/VideoViewNativeComponent';
+
+const LINKING_ERROR =
+  `The package 'react-native-video' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const ComponentName = 'VideoView';
+
+export const NativeVideoView =
+  UIManager.hasViewManagerConfig(ComponentName) != null
+    ? VideoViewNativeComponent
+    : () => {
+        throw new Error(LINKING_ERROR);
+      };