amazon-ivs-react-native-player 1.0.0

package/ios/AmazonIvsView.swift

@@ -0,0 +1,414 @@
+import Foundation
+import UIKit
+import AmazonIVSPlayer
+
+@objc(AmazonIvsView)
+class AmazonIvsView: UIView, IVSPlayer.Delegate {
+    @objc var onSeek: RCTDirectEventBlock?
+    @objc var onData: RCTDirectEventBlock?
+    @objc var onVideoStatistics: RCTDirectEventBlock?
+    @objc var onPlayerStateChange: RCTDirectEventBlock?
+    @objc var onDurationChange: RCTDirectEventBlock?
+    @objc var onQualityChange: RCTDirectEventBlock?
+    @objc var onRebuffering: RCTDirectEventBlock?
+    @objc var onLoadStart: RCTDirectEventBlock?
+    @objc var onLoad: RCTDirectEventBlock?
+    @objc var onTextCue: RCTDirectEventBlock?
+    @objc var onTextMetadataCue: RCTDirectEventBlock?
+    @objc var onLiveLatencyChange: RCTDirectEventBlock?
+    @objc var onProgress: RCTDirectEventBlock?
+    @objc var onTimePoint: RCTDirectEventBlock?
+
+    @objc var onError: RCTDirectEventBlock?
+
+    private let player = IVSPlayer()
+    private let playerView = IVSPlayerView()
+    private var finishedLoading: Bool = false;
+
+    private var progressObserverToken: Any?
+    private var playerObserverToken: Any?
+    private var timePointObserver: Any?
+    private var oldQualities: [IVSQuality] = [];
+    private var lastLiveLatency: Double?;
+    private var lastBitrate: Int?;
+    private var lastDuration: CMTime?;
+    private var lastFramesDropped: Int?;
+    private var lastFramesDecoded: Int?;
+
+    override init(frame: CGRect) {
+        self.muted = player.muted
+        self.liveLowLatency = player.isLiveLowLatency
+        self.autoQualityMode = player.autoQualityMode
+        self.playbackRate = Double(player.playbackRate)
+        self.logLevel = NSNumber(value: player.logLevel.rawValue)
+        self.progressInterval = 1
+        self.volume = Double(player.volume)
+        self.breakpoints = []
+        self.initialBufferDuration = 1
+
+        super.init(frame: frame)
+
+        self.addSubview(self.playerView)
+        self.playerView.autoresizingMask = [.flexibleHeight, .flexibleWidth]
+        self.addProgressObserver()
+        self.addPlayerObserver()
+        self.addTimePointObserver()
+        self.addApplicationLifecycleObservers()
+
+        player.delegate = self
+        self.playerView.player = player
+    }
+
+    deinit {
+        self.removeProgressObserver()
+        self.removePlayerObserver()
+        self.removeTimePointObserver()
+        self.removeApplicationLifecycleObservers()
+    }
+
+    func load(urlString: String) {
+        finishedLoading = false
+        let url = URL(string: urlString)
+
+        onLoadStart?(["": NSNull()])
+        player.load(url)
+    }
+
+    @objc var progressInterval: NSNumber {
+        // TODO: Figure out why updatating observer does not work and results in multiple calls per second
+        didSet {
+            self.removeProgressObserver()
+            self.addProgressObserver()
+        }
+    }
+
+    @objc var muted: Bool {
+        didSet {
+            player.muted = muted
+        }
+    }
+
+    @objc var playbackRate: Double {
+        didSet {
+            player.playbackRate = Float(playbackRate)
+        }
+    }
+
+    @objc var liveLowLatency: Bool {
+        didSet {
+            player.setLiveLowLatencyEnabled(liveLowLatency)
+        }
+    }
+
+    @objc var quality: NSDictionary? {
+        didSet {
+            let newQuality = findQuality(quality: quality)
+            player.quality = newQuality
+        }
+    }
+
+    @objc var autoQualityMode: Bool {
+        didSet {
+            player.autoQualityMode = autoQualityMode
+        }
+    }
+
+    @objc var autoMaxQuality: NSDictionary? {
+        didSet {
+            let quality = findQuality(quality: autoMaxQuality)
+            player.setAutoMaxQuality(quality)
+        }
+    }
+    
+    @objc var initialBufferDuration: Double {
+        didSet {
+            let parsedTime = CMTimeMakeWithSeconds(initialBufferDuration, preferredTimescale: 10)
+            player.setInitialBufferDuration(parsedTime)
+        }
+    }
+
+    private func findQuality(quality: NSDictionary?) -> IVSQuality? {
+        let quality = player.qualities.first(where: {
+            $0.name == quality?["name"] as? String &&
+            $0.codecs == quality?["codecs"] as? String &&
+            $0.bitrate == quality?["bitrate"] as? Int &&
+            $0.framerate == quality?["framerate"] as? Float &&
+            $0.width == quality?["width"] as? Int &&
+            $0.height == quality?["height"] as? Int
+        })
+
+        return quality
+    }
+
+    private func getDuration(_ duration: CMTime) -> NSNumber? {
+        let value: NSNumber?
+        if duration.isNumeric {
+            value = NSNumber(value: duration.seconds);
+        } else {
+            value = 0
+        }
+        return value
+    }
+    
+    @objc var streamUrl: String? {
+        didSet {
+            if let url = streamUrl, !streamUrl!.isEmpty {
+                self.load(urlString: url)
+            }
+        }
+    }
+
+    @objc var volume: Double {
+        didSet {
+            player.volume = Float(volume)
+        }
+    }
+
+    @objc var logLevel: NSNumber {
+        didSet {
+            switch logLevel {
+            case 0:
+                player.logLevel = IVSPlayer.LogLevel.debug
+            case 1:
+                player.logLevel = IVSPlayer.LogLevel.info
+            case 2:
+                player.logLevel = IVSPlayer.LogLevel.warning
+            case 3:
+                player.logLevel = IVSPlayer.LogLevel.error
+            default:
+                break
+            }
+        }
+    }
+    
+    @objc var breakpoints: NSArray {
+        didSet {
+            self.removeTimePointObserver()
+            self.addTimePointObserver()
+        }
+    }
+
+    @objc func play() {
+        player.play()
+    }
+
+    @objc func pause() {
+        player.pause()
+    }
+
+    @objc func seek(position: Double) {
+        let parsedTime = CMTimeMakeWithSeconds(position, preferredTimescale: 1000000)
+        player.seek(to: parsedTime)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func addPlayerObserver() {
+        playerObserverToken = player.addPeriodicTimeObserver(forInterval: CMTime(seconds: 1, preferredTimescale: CMTimeScale(NSEC_PER_SEC)), queue: .main) {
+            [weak self] time in
+            if self?.lastLiveLatency != self?.player.liveLatency.seconds {
+                if let liveLatency = self?.player.liveLatency.seconds {
+                    let parsedValue = 1000*liveLatency
+                    self?.onLiveLatencyChange?(["liveLatency": parsedValue])
+                } else {
+                    self?.onLiveLatencyChange?(["liveLatency": NSNull()])
+                }
+
+                self?.lastLiveLatency = self?.player.liveLatency.seconds
+            }
+
+            if
+                self?.lastBitrate != self?.player.videoBitrate ||
+                self?.lastDuration != self?.player.duration ||
+                self?.lastFramesDecoded != self?.player.videoFramesDecoded ||
+                self?.lastFramesDropped != self?.player.videoFramesDropped ||
+                self?.onVideoStatistics != nil {
+                let videoData: [String: Any] = [
+                    "duration": self?.getDuration(self!.player.duration) ?? NSNull(),
+                    "bitrate": self?.player.videoBitrate ?? NSNull(),
+                    "framesDropped": self?.player.videoFramesDropped ?? NSNull(),
+                    "framesDecoded": self?.player.videoFramesDecoded ?? NSNull()
+                ]
+
+                self?.onVideoStatistics?(["videoData": videoData])
+
+                self?.lastBitrate = self?.player.videoBitrate
+                self?.lastDuration = self?.player.duration
+                self?.lastFramesDropped = self?.player.videoFramesDropped
+                self?.lastFramesDecoded = self?.player.videoFramesDecoded
+            }
+        }
+    }
+
+    private var didPauseOnBackground = false
+
+    @objc private func applicationDidEnterBackground(notification: Notification) {
+        if player.state == .playing || player.state == .buffering {
+            didPauseOnBackground = true
+            pause()
+        } else {
+            didPauseOnBackground = false
+        }
+    }
+
+    @objc private func applicationDidBecomeActive(notification: Notification) {
+        if didPauseOnBackground && player.error == nil {
+            play()
+            didPauseOnBackground = false
+        }
+    }
+
+    private func addApplicationLifecycleObservers() {
+        NotificationCenter.default.addObserver(self, selector: #selector(applicationDidEnterBackground(notification:)), name: UIApplication.didEnterBackgroundNotification, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(applicationDidBecomeActive(notification:)), name: UIApplication.didBecomeActiveNotification, object: nil)
+    }
+
+    private func removeApplicationLifecycleObservers() {
+        NotificationCenter.default.removeObserver(self, name: UIApplication.didEnterBackgroundNotification, object: nil)
+        NotificationCenter.default.removeObserver(self, name: UIApplication.willEnterForegroundNotification, object: nil)
+    }
+    
+    private func mapPlayerState(state: IVSPlayer.State) -> String {
+        switch state {
+        case IVSPlayer.State.playing: return "Playing"
+        case IVSPlayer.State.buffering: return "Buffering"
+        case IVSPlayer.State.ready: return "Ready"
+        case IVSPlayer.State.idle: return "Idle"
+        case IVSPlayer.State.ended: return "Ended"
+        }
+    }
+
+    func addProgressObserver() {
+        progressObserverToken = player.addPeriodicTimeObserver(forInterval: CMTime(seconds: Double(truncating: progressInterval), preferredTimescale: CMTimeScale(NSEC_PER_SEC)), queue: .main) {
+            [weak self] time in
+            self?.onProgress?(["position": (self?.player.position.seconds ?? nil) as Any])
+        }
+    }
+
+    func addTimePointObserver() {
+        timePointObserver = player.addBoundaryTimeObserver(forTimes: breakpoints as! [NSNumber], queue: .main) {
+            [weak self] in
+            self?.onTimePoint?(["position": (self?.player.position.seconds ?? nil) as Any])
+
+        }
+    }
+
+    func removePlayerObserver() {
+        if let token = playerObserverToken {
+            player.removeTimeObserver(token)
+            self.playerObserverToken = nil
+        }
+    }
+
+    func removeProgressObserver() {
+        if let token = progressObserverToken {
+            player.removeTimeObserver(token)
+            self.progressObserverToken = nil
+        }
+    }
+
+    func removeTimePointObserver() {
+        if let token = timePointObserver {
+            player.removeTimeObserver(token)
+            self.timePointObserver = nil
+        }
+    }
+
+    func player(_ player: IVSPlayer, didSeekTo time: CMTime) {
+        onSeek?(["position": CMTimeGetSeconds(time)])
+    }
+
+    func player(_ player: IVSPlayer, didChangeState state: IVSPlayer.State) {
+        onPlayerStateChange?(["state": mapPlayerState(state: state)])
+
+        if state == IVSPlayer.State.playing, finishedLoading == false {
+            let duration = getDuration(player.duration)
+            onLoad?(["duration": duration ?? NSNull()])
+            finishedLoading = true
+        }
+        
+        if state == IVSPlayer.State.ready {
+            if player.qualities != oldQualities {
+                let qualities: NSMutableArray = []
+                for quality in player.qualities {
+                    let qualityData: [String: Any] = [
+                        "name": quality.name,
+                        "codecs": quality.codecs,
+                        "bitrate": quality.bitrate,
+                        "framerate": quality.framerate,
+                        "width": quality.width,
+                        "height": quality.height
+                    ]
+                    
+                    qualities.add(qualityData)
+                }
+                
+                onData?(["playerData": [
+                    "qualities": qualities,
+                    "version": player.version,
+                    "sessionId": player.sessionId
+                ]])
+            }
+
+            oldQualities = player.qualities
+        }
+    }
+
+    func player(_ player: IVSPlayer, didChangeDuration duration: CMTime) {
+        let parsedDuration = getDuration(duration)
+        onDurationChange?(["duration": parsedDuration ?? NSNull()])
+    }
+
+    func player(_ player: IVSPlayer, didChangeQuality quality: IVSQuality?) {
+            if quality == nil {
+                onQualityChange?(["quality": NSNull()])
+            } else {
+                let qualityData: [String: Any] = [
+                    "name": quality?.name ?? "",
+                    "codecs": quality?.codecs ?? "",
+                    "bitrate": quality?.bitrate ?? 0,
+                    "framerate": quality?.framerate ?? 0,
+                    "width": quality?.width ?? 0,
+                    "height": quality?.height ?? 0
+                ]
+
+                onQualityChange?(["quality": qualityData])
+            }
+    }
+
+    func player(_ player: IVSPlayer, didOutputCue cue: IVSCue) {
+        if let cue = cue as? IVSTextCue {
+            let textCue: [String: Any] = [
+                "type": cue.type.rawValue,
+                "line": cue.line,
+                "size": cue.size,
+                "position": cue.position,
+                "text": cue.text,
+                "textAlignment": cue.textAlignment
+            ]
+
+            onTextCue?(["textCue": textCue])
+        }
+
+        if let cue = cue as? IVSTextMetadataCue {
+            let textMetadataCue = [
+                "type": cue.type.rawValue,
+                "text": cue.text,
+                "textDescription": cue.textDescription
+
+            ]
+
+            onTextMetadataCue?(["textMetadataCue": textMetadataCue])
+        }
+    }
+
+    func playerWillRebuffer(_ player: IVSPlayer) {
+        onRebuffering?(["": NSNull()])
+    }
+
+    func player(_ player: IVSPlayer, didFailWithError error: Error) {
+        onError?(["error": error.localizedDescription])
+    }
+}

package/lib/commonjs/IVSPlayer.js

@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactNative = require("react-native");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const VIEW_NAME = 'AmazonIvs';
+const IVSPlayer = (0, _reactNative.requireNativeComponent)(VIEW_NAME);
+
+function parseDuration(duration) {
+  if (duration == null) {
+    return duration;
+  }
+
+  return duration > 0 ? duration : Infinity;
+}
+
+const IVSPlayerContainer = /*#__PURE__*/_react.default.forwardRef(({
+  style,
+  streamUrl,
+  paused,
+  muted,
+  autoplay = true,
+  liveLowLatency,
+  playbackRate,
+  logLevel,
+  progressInterval,
+  volume,
+  quality,
+  autoMaxQuality,
+  autoQualityMode,
+  breakpoints = [],
+  maxBitrate,
+  initialBufferDuration,
+  onSeek,
+  onData,
+  onVideoStatistics,
+  onPlayerStateChange,
+  onDurationChange,
+  onQualityChange,
+  onRebuffering,
+  onLoadStart,
+  onLoad,
+  onLiveLatencyChange,
+  onTextCue,
+  onTextMetadataCue,
+  onProgress,
+  onError,
+  onTimePoint,
+  children
+}, ref) => {
+  const mediaPlayerRef = (0, _react.useRef)(null);
+  const initialized = (0, _react.useRef)(false);
+  const play = (0, _react.useCallback)(() => {
+    _reactNative.UIManager.dispatchViewManagerCommand((0, _reactNative.findNodeHandle)(mediaPlayerRef.current), _reactNative.UIManager.getViewManagerConfig(VIEW_NAME).Commands.play, []);
+  }, []);
+  const pause = (0, _react.useCallback)(() => {
+    _reactNative.UIManager.dispatchViewManagerCommand((0, _reactNative.findNodeHandle)(mediaPlayerRef.current), _reactNative.UIManager.getViewManagerConfig(VIEW_NAME).Commands.pause, []);
+  }, []);
+  const seekTo = (0, _react.useCallback)(value => {
+    _reactNative.UIManager.dispatchViewManagerCommand((0, _reactNative.findNodeHandle)(mediaPlayerRef.current), _reactNative.UIManager.getViewManagerConfig(VIEW_NAME).Commands.seekTo, [value]);
+  }, []);
+  (0, _react.useEffect)(() => {
+    if (initialized.current || autoplay) {
+      if (paused) {
+        pause();
+      } else {
+        play();
+      }
+    }
+
+    initialized.current = true;
+  }, [pause, paused, play, autoplay]);
+  (0, _react.useImperativeHandle)(ref, () => ({
+    play,
+    pause,
+    seekTo
+  }), [play, pause, seekTo]);
+
+  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 onLoadHandler = event => {
+    if (!paused) {
+      play();
+    } else {
+      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.default.createElement(_reactNative.View, {
+    style: [styles.container, style],
+    ref: ref
+  }, /*#__PURE__*/_react.default.createElement(IVSPlayer, {
+    testID: "IVSPlayer",
+    muted: muted,
+    liveLowLatency: liveLowLatency,
+    style: styles.mediaPlayer,
+    ref: mediaPlayerRef,
+    playbackRate: playbackRate,
+    streamUrl: streamUrl,
+    logLevel: logLevel,
+    progressInterval: progressInterval,
+    volume: volume,
+    quality: quality,
+    initialBufferDuration: initialBufferDuration,
+    autoMaxQuality: autoMaxQuality,
+    autoQualityMode: autoQualityMode,
+    breakpoints: breakpoints,
+    maxBitrate: maxBitrate,
+    onVideoStatistics: onVideoStatistics ? onVideoStatisticsHandler : undefined,
+    onData: onDataHandler,
+    onSeek: onSeekHandler,
+    onQualityChange: onQualityChangeHandler,
+    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.default.createElement(_reactNative.View, {
+    style: styles.children
+  }, children));
+});
+
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  },
+  mediaPlayer: {
+    flex: 1
+  },
+  children: {
+    position: 'absolute',
+    width: '100%',
+    height: '100%'
+  }
+});
+
+var _default = IVSPlayerContainer;
+exports.default = _default;
+//# sourceMappingURL=IVSPlayer.js.map

package/lib/commonjs/IVSPlayer.js.flow

@@ -0,0 +1,53 @@
+/**
+ * Flowtype definitions for IVSPlayer
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.13.0
+ * @flow
+ */
+
+import * as React from 'react';
+import type { ViewStyleProp } from 'react-native/Libraries/StyleSheet/StyleSheet';
+import typeof { LogLevel } from './enums';
+import type {
+  Quality,
+  PlayerData,
+  TextCue,
+  TextMetadataCue,
+  VideoData,
+  IVSPlayerRef,
+} from './types';
+
+declare type Props = {|
+  style?: ViewStyleProp,
+  paused?: boolean,
+  muted?: boolean,
+  autoplay?: boolean,
+  streamUrl?: string,
+  liveLowLatency?: boolean,
+  playbackRate?: number,
+  logLevel?: LogLevel,
+  progressInterval?: number,
+  volume?: number,
+  quality?: Quality | null,
+  autoMaxQuality?: Quality | null,
+  autoQualityMode?: boolean,
+  breakpoints?: number[],
+  maxBitrate?: number,
+  onSeek?: (position: number) => void,
+  onData?: (data: PlayerData) => void,
+  onVideoStatistics?: (data: VideoData) => void,
+  onPlayerStateChange?: (state: number) => void,
+  onDurationChange?: (duration: number | null) => void,
+  onQualityChange?: (quality: Quality | null) => void,
+  onRebuffering?: () => void,
+  onLoadStart?: () => void,
+  onLoad?: (duration: number | null) => void,
+  onLiveLatencyChange?: (liveLatency: number) => void,
+  onTextCue?: (textCue: TextCue) => void,
+  onTextMetadataCue?: (textMetadataCue: TextMetadataCue) => void,
+  onProgress?: (progress: number) => void,
+  onError?: (error: string) => void,
+  onTimePoint?: (position: number) => void,
+|};
+declare var IVSPlayerContainer: React.AbstractComponent<Props, IVSPlayerRef>;
+declare export default typeof IVSPlayerContainer;