expo-libvlc-player/src/LibVlcPlayer.types.ts

LibVLC Player for Expo

import type { ViewProps } from "react-native";

export interface LibVlcPlayerViewRef {
  /**
   * Starts playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly play: () => Promise<void>;
  /**
   * Pauses playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly pause: () => Promise<void>;
  /**
   * Stops playback of the current player
   *
   * @returns A promise which resolves to `void`
   */
  readonly stop: () => Promise<void>;
  /**
   * Sets the position or time of the current player
   *
   * @param value - Must be a number equal or greater than `0`
   * @param type - Defaults to `"position"`
   *
   * @returns A promise which resolves to `void`
   */
  readonly seek: (value: number, type?: "position" | "time") => Promise<void>;
  /**
   * Posts an answer to a `Dialog`
   *
   * @param action - Must be an integer of `1` or `2`
   *
   * @returns A promise which resolves to `void`
   */
  readonly postAction: (action: 1 | 2) => Promise<void>;
  /**
   * Dismisses a `Dialog`
   *
   * @returns A promise which resolves to `void`
   */
  readonly dismiss: () => Promise<void>;
}

export type LibVlcSource = string | number | null;

export interface Tracks {
  audio?: number;
  video?: number;
  subtitle?: number;
}

export interface Slave {
  source: NonNullable<LibVlcSource>;
  type: "audio" | "subtitle";
  selected?: boolean;
}

export type AudioMixingMode =
  | "mixWithOthers"
  | "duckOthers"
  | "auto"
  | "doNotMix";

export interface NativeEventProps {
  target: number;
}

export interface NativeEvent<T> {
  nativeEvent: T & NativeEventProps;
}

export type LibVlcEvent<T> = Omit<T & NativeEventProps, "target">;

export interface Track {
  id: number;
  name: string;
}

export interface MediaTracks {
  audio: Track[];
  video: Track[];
  subtitle: Track[];
}

export interface MediaInfo {
  width: number;
  height: number;
  length: number;
  seekable: boolean;
  tracks: MediaTracks;
}

export interface Dialog {
  title: string;
  text: string;
  cancelText?: string;
  action1Text?: string;
  action2Text?: string;
}

/**
 * @hidden
 */
type BufferingListener = () => void;

/**
 * @hidden
 */
type PlayingListener = () => void;

/**
 * @hidden
 */
type PausedListener = () => void;

/**
 * @hidden
 */
type StoppedListener = () => void;

/**
 * @hidden
 */
type EndReachedListener = () => void;

/**
 * @hidden
 */
type EncounteredErrorListener = (event: NativeEvent<Error>) => void;

export type Error = { error: string };

/**
 * @hidden
 */
type TimeChangedListener = (event: NativeEvent<Time>) => void;

export type Time = { time: number };

/**
 * @hidden
 */
type PositionChangedListener = (event: NativeEvent<Position>) => void;

export type Position = { position: number };

/**
 * @hidden
 */
type ESAddedListener = (event: NativeEvent<MediaTracks>) => void;

/**
 * @hidden
 */
type DialogDisplayListener = (event: NativeEvent<Dialog>) => void;

/**
 * @hidden
 */
type FirstPlayListener = (event: NativeEvent<MediaInfo>) => void;

/**
 * @hidden
 */
type BackgroundListener = () => void;

/**
 * @hidden
 */
export interface LibVlcPlayerViewNativeProps {
  ref?: React.Ref<LibVlcPlayerViewRef>;
  source?: LibVlcSource;
  options?: string[];
  tracks?: Tracks;
  slaves?: Slave[];
  scale?: number;
  aspectRatio?: string | null;
  rate?: number;
  time?: number;
  volume?: number;
  mute?: boolean;
  audioMixingMode?: AudioMixingMode;
  repeat?: boolean;
  playInBackground?: boolean;
  autoplay?: boolean;
  onBuffering?: BufferingListener;
  onPlaying?: PlayingListener;
  onPaused?: PausedListener;
  onStopped?: StoppedListener;
  onEndReached?: EndReachedListener;
  onEncounteredError?: EncounteredErrorListener;
  onTimeChanged?: TimeChangedListener;
  onPositionChanged?: PositionChangedListener;
  onESAdded?: ESAddedListener;
  onDialogDisplay?: DialogDisplayListener;
  onFirstPlay?: FirstPlayListener;
  onBackground?: BackgroundListener;
}

export interface LibVlcPlayerViewProps extends ViewProps {
  /**
   * Sets the source of the media to be played. Set to `null` to release the player
   */
  source: LibVlcSource;
  /**
   * Sets the VLC options to initialize the player with
   *
   * https://wiki.videolan.org/VLC_command-line_help/
   *
   * @example ["--network-caching=1000"]
   *
   * @default []
   */
  options?: string[];
  /**
   * Sets the player audio, video and subtitle tracks
   *
   * @example
   * ```tsx
   * <LibVlcPlayerView
   *    tracks={{
   *      audio: 0,
   *      video: 1,
   *      subtitle: 2,
   *    }}
   * />
   * ```
   *
   * @default undefined
   */
  tracks?: Tracks;
  /**
   * Sets the player audio and subtitle slaves
   *
   * @example
   * ```tsx
   * <LibVlcPlayerView
   *    slaves={[
   *      {
   *        source: "file://path/to/subtitle.srt",
   *        type: "subtitle",
   *        selected: true
   *      },
   *    ]}
   * />
   * ```
   *
   * @default []
   */
  slaves?: Slave[];
  /**
   * Sets the player scaling factor. Must be a float equal or greater than `0`
   *
   * @default 0
   */
  scale?: number;
  /**
   * Sets the player aspect ratio. Must be a valid string or `null` for default
   *
   * @example "16:9"
   *
   * @default undefined
   */
  aspectRatio?: string | null;
  /**
   * Sets the player rate. Must be a float equal or greater than `1`
   *
   * @default 1
   */
  rate?: number;
  /**
   * Sets the initial player time. Must be an integer in milliseconds
   *
   * @default 0
   */
  time?: number;
  /**
   * Sets the player volume. Must be an integer between `0` and `100`
   *
   * @default 100
   */
  volume?: number;
  /**
   * Sets the player volume to `0` when `true`. Previous value is set when `false`
   *
   * @default false
   */
  mute?: boolean;
  /**
   * Determines how the player will interact with other audio playing in the system
   *
   * @default "auto"
   */
  audioMixingMode?: AudioMixingMode;
  /**
   * Determines whether the media should repeat once ended
   *
   * @default false
   */
  repeat?: boolean;
  /**
   * Determines whether the media should continue playing in the background
   *
   * @default false
   */
  playInBackground?: boolean;
  /**
   * Determines whether the media should autoplay once created
   *
   * @default true
   */
  autoplay?: boolean;
  /**
   * Called after the `Buffering` player event
   */
  onBuffering?: () => void;
  /**
   * Called after the `Playing` player event
   */
  onPlaying?: () => void;
  /**
   * Called after the `Paused` player event
   */
  onPaused?: () => void;
  /**
   * Called after the `Stopped` player event
   */
  onStopped?: () => void;
  /**
   * Called after the `EndReached` player event
   */
  onEndReached?: () => void;
  /**
   * Called after the `EncounteredError` player event
   */
  onEncounteredError?: (event: Error) => void;
  /**
   * Called after the `TimeChanged` player event
   */
  onTimeChanged?: (event: Time) => void;
  /**
   * Called after the `PositionChanged` player event
   */
  onPositionChanged?: (event: Position) => void;
  /**
   * Called after the `ESAdded` player event
   */
  onESAdded?: (event: MediaTracks) => void;
  /**
   * Called after a `Dialog` needs to be displayed
   */
  onDialogDisplay?: (event: Dialog) => void;
  /**
   * Called after the player first playing event
   */
  onFirstPlay?: (event: MediaInfo) => void;
  /**
   * Called after the player enters the background
   */
  onBackground?: () => void;
}