amazon-ivs-react-native-player/lib/module/IVSPlayer.js

amazon-ivs-react-native-player

import React, { useCallback, useEffect, useImperativeHandle, useRef } from 'react';
import { requireNativeComponent, StyleSheet, UIManager, findNodeHandle, View, Platform } from 'react-native';
const VIEW_NAME = 'AmazonIvs';
const IVSPlayer = requireNativeComponent(VIEW_NAME);

function parseDuration(duration) {
  if (duration == null) {
    return duration;
  }

  return duration > 0 ? duration : Infinity;
}

const IVSPlayerContainer = /*#__PURE__*/React.forwardRef((_ref, ref) => {
  let {
    style,
    streamUrl,
    paused,
    muted,
    loop = false,
    resizeMode,
    autoplay = true,
    liveLowLatency,
    rebufferToLive,
    playbackRate,
    pipEnabled,
    logLevel,
    progressInterval,
    volume,
    quality,
    autoMaxQuality,
    autoQualityMode,
    breakpoints = [],
    maxBitrate,
    initialBufferDuration,
    onSeek,
    onData,
    onVideoStatistics,
    onPlayerStateChange,
    onDurationChange,
    onQualityChange,
    onPipChange,
    onRebuffering,
    onLoadStart,
    onLoad,
    onLiveLatencyChange,
    onTextCue,
    onTextMetadataCue,
    onProgress,
    onError,
    onTimePoint,
    children
  } = _ref;
  const mediaPlayerRef = useRef(null);
  const initialized = useRef(false);
  const play = useCallback(() => {
    UIManager.dispatchViewManagerCommand(findNodeHandle(mediaPlayerRef.current), UIManager.getViewManagerConfig(VIEW_NAME).Commands.play, []);
  }, []);
  const pause = useCallback(() => {
    UIManager.dispatchViewManagerCommand(findNodeHandle(mediaPlayerRef.current), UIManager.getViewManagerConfig(VIEW_NAME).Commands.pause, []);
  }, []);
  const seekTo = useCallback(value => {
    UIManager.dispatchViewManagerCommand(findNodeHandle(mediaPlayerRef.current), UIManager.getViewManagerConfig(VIEW_NAME).Commands.seekTo, [value]);
  }, []);
  const setOrigin = useCallback(value => {
    UIManager.dispatchViewManagerCommand(findNodeHandle(mediaPlayerRef.current), UIManager.getViewManagerConfig(VIEW_NAME).Commands.setOrigin, [value]);
  }, []);
  const togglePip = useCallback(() => {
    UIManager.dispatchViewManagerCommand(findNodeHandle(mediaPlayerRef.current), UIManager.getViewManagerConfig(VIEW_NAME).Commands.togglePip, []);
  }, []);
  useEffect(() => {
    if (initialized.current || autoplay) {
      if (paused) {
        pause();
      } else {
        play();
      }
    }

    initialized.current = true;
  }, [pause, paused, play, autoplay]);
  useImperativeHandle(ref, () => ({
    play,
    pause,
    seekTo,
    setOrigin,
    togglePip
  }), [play, pause, seekTo, setOrigin, togglePip]);

  const onSeekHandler = event => {
    const {
      position
    } = event.nativeEvent;
    onSeek === null || onSeek === void 0 ? void 0 : onSeek(position);
  };

  const onPlayerStateChangeHandler = event => {
    const {
      state
    } = event.nativeEvent;
    onPlayerStateChange === null || onPlayerStateChange === void 0 ? void 0 : onPlayerStateChange(state);
  };

  const onDurationChangeHandler = event => {
    const {
      duration
    } = event.nativeEvent;
    onDurationChange === null || onDurationChange === void 0 ? void 0 : onDurationChange(parseDuration(duration));
  };

  const onQualityChangeHandler = event => {
    const {
      quality: newQuality
    } = event.nativeEvent;
    onQualityChange === null || onQualityChange === void 0 ? void 0 : onQualityChange(newQuality);
  };

  const onPipChangeHandler = event => {
    const {
      active
    } = event.nativeEvent;
    onPipChange === null || onPipChange === void 0 ? void 0 : onPipChange(active === true || active === 'true');
  };

  const onLoadHandler = event => {
    if (Platform.OS === 'android') {
      const shouldAutoPlay = autoplay && !paused;
      shouldAutoPlay ? play() : pause();
    }

    const {
      duration
    } = event.nativeEvent;
    onLoad === null || onLoad === void 0 ? void 0 : onLoad(parseDuration(duration));
  };

  const onLiveLatencyChangeHandler = event => {
    const {
      liveLatency
    } = event.nativeEvent;
    onLiveLatencyChange === null || onLiveLatencyChange === void 0 ? void 0 : onLiveLatencyChange(liveLatency);
  };

  const onDataHandler = event => {
    const {
      playerData
    } = event.nativeEvent;
    onData === null || onData === void 0 ? void 0 : onData(playerData);
  };

  const onTextCueHandler = event => {
    const {
      textCue
    } = event.nativeEvent;
    onTextCue === null || onTextCue === void 0 ? void 0 : onTextCue(textCue);
  };

  const onVideoStatisticsHandler = event => {
    const {
      videoData
    } = event.nativeEvent;
    const statistics = { ...videoData,
      duration: parseDuration(videoData.duration)
    };
    onVideoStatistics === null || onVideoStatistics === void 0 ? void 0 : onVideoStatistics(statistics);
  };

  const onTextMetadataCueHandler = event => {
    const {
      textMetadataCue
    } = event.nativeEvent;
    onTextMetadataCue === null || onTextMetadataCue === void 0 ? void 0 : onTextMetadataCue(textMetadataCue);
  };

  const onProgressHandler = event => {
    const {
      position
    } = event.nativeEvent;
    onProgress === null || onProgress === void 0 ? void 0 : onProgress(position);
  };

  const onErrorHandler = event => {
    const {
      error
    } = event.nativeEvent;
    onError === null || onError === void 0 ? void 0 : onError(error);
  };

  const onTimePointHandler = event => {
    const {
      position
    } = event.nativeEvent;
    onTimePoint === null || onTimePoint === void 0 ? void 0 : onTimePoint(position);
  };

  return /*#__PURE__*/React.createElement(View, {
    style: [styles.container, style],
    ref: ref
  }, /*#__PURE__*/React.createElement(IVSPlayer, {
    testID: "IVSPlayer",
    muted: muted,
    loop: loop,
    liveLowLatency: liveLowLatency,
    rebufferToLive: rebufferToLive,
    style: styles.mediaPlayer,
    ref: mediaPlayerRef,
    playbackRate: playbackRate,
    streamUrl: streamUrl,
    logLevel: logLevel,
    resizeMode: resizeMode,
    progressInterval: progressInterval,
    volume: volume,
    quality: quality,
    initialBufferDuration: initialBufferDuration,
    autoMaxQuality: autoMaxQuality,
    autoQualityMode: autoQualityMode,
    breakpoints: breakpoints,
    maxBitrate: maxBitrate,
    pipEnabled: pipEnabled,
    onVideoStatistics: onVideoStatistics ? onVideoStatisticsHandler : undefined,
    onData: onDataHandler,
    onSeek: onSeekHandler,
    onQualityChange: onQualityChangeHandler,
    onPipChange: onPipChangeHandler,
    onPlayerStateChange: onPlayerStateChangeHandler,
    onDurationChange: onDurationChangeHandler,
    onRebuffering: onRebuffering,
    onLoadStart: onLoadStart,
    onLoad: onLoadHandler,
    onTextCue: onTextCueHandler,
    onTextMetadataCue: onTextMetadataCueHandler,
    onProgress: onProgressHandler,
    onLiveLatencyChange: onLiveLatencyChange ? onLiveLatencyChangeHandler : undefined,
    onError: onErrorHandler,
    onTimePoint: onTimePointHandler
  }), /*#__PURE__*/React.createElement(View, {
    style: styles.children
  }, children));
});
const styles = StyleSheet.create({
  container: {
    flex: 1
  },
  mediaPlayer: {
    flex: 1
  },
  children: {
    position: 'absolute',
    width: '100%',
    height: '100%'
  }
});
export default IVSPlayerContainer;
//# sourceMappingURL=IVSPlayer.js.map