Merge pull request #1076 from react-native-community/feature/ios-configurable-seek

* [onLoad](#onload)

* [onLoadStart](#onloadstart)

### Methods

* [seek](#seek)

### Configurable props

#### allowsExternalPlayback

Indicates whether the player allows switching to external playback mode such as AirPlay or HDMI.

* **true (default)** - allow switching to external playback mode

Platforms: all

### Methods

Methods operate on a ref to the Video element. You can create a ref using code like:

```

return (

  <Video source={...}

    ref => (this.player = ref) />

);

```

#### seek()

`seek(seconds)`

Seek to the specified position represented by seconds. seconds is a float value.

`seek()` can only be called after the `onLoad` event has fired.

Example:

```

this.player.seek(200); // Seek to 3 minutes, 20 seconds

```

Platforms: all

##### Exact seek

By default iOS seeks within 100 milliseconds of the target position. If you need more accuracy, you can use the seek with tolerance method:

`seek(seconds, tolerance)`

tolerance is the max distance in milliseconds from the seconds position that's allowed. Using a more exact tolerance can cause seeks to take longer. If you want to seek exactly, set tolerance to 0.

Example:

```

this.player.seek(120, 50); // Seek to 2 minutes with +/- 50 milliseconds accuracy

```

Platforms: iOS

### Additional props

To see the full list of available props, you can check the [propTypes](https://github.com/react-native-community/react-native-video/blob/master/Video.js#L246) of the Video.js component.

import React, {Component} from 'react';

import PropTypes from 'prop-types';

import {StyleSheet, requireNativeComponent, NativeModules, View, ViewPropTypes, Image} from 'react-native';

import {StyleSheet, requireNativeComponent, NativeModules, View, ViewPropTypes, Image, Platform} from 'react-native';

import resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';

import TextTrackType from './TextTrackType';

import VideoResizeMode from './VideoResizeMode.js';

    this._root.setNativeProps(nativeProps);

  }

  seek = (time) => {

  seek = (time, tolerance = 100) => {

    if (Platform.OS === 'ios') {

      this.setNativeProps({

        seek: {

          time,

          tolerance

        }

      });

    } else {

      this.setNativeProps({ seek: time });

    }

  };

  presentFullscreenPlayer = () => {

Video.propTypes = {

  /* Native only */

  src: PropTypes.object,

  seek: PropTypes.number,

  seek: PropTypes.oneOfType([

    PropTypes.number,

    PropTypes.object

  ]),

  fullscreen: PropTypes.bool,

  onVideoLoadStart: PropTypes.func,

  onVideoLoad: PropTypes.func,

- (void)setCurrentTime:(float)currentTime

{

  [self setSeek: currentTime];

  NSDictionary *info = @{

                         @"time": [NSNumber numberWithFloat:currentTime],

                         @"tolerance": [NSNumber numberWithInt:100]

                         };

  [self setSeek:info];

}

- (void)setSeek:(float)seekTime

- (void)setSeek:(NSDictionary *)info

{

  int timeScale = 10000;

  NSNumber *seekTime = info[@"time"];

  NSNumber *seekTolerance = info[@"tolerance"];

  int timeScale = 1000;

  AVPlayerItem *item = _player.currentItem;

  if (item && item.status == AVPlayerItemStatusReadyToPlay) {

    // TODO check loadedTimeRanges

    CMTime cmSeekTime = CMTimeMakeWithSeconds(seekTime, timeScale);

    CMTime cmSeekTime = CMTimeMakeWithSeconds([seekTime floatValue], timeScale);

    CMTime current = item.currentTime;

    // TODO figure out a good tolerance level

    CMTime tolerance = CMTimeMake(1000, timeScale);

    CMTime tolerance = CMTimeMake([seekTolerance floatValue], timeScale);

    BOOL wasPaused = _paused;

    if (CMTimeCompare(current, cmSeekTime) != 0) {

        }

        if(self.onVideoSeek) {

            self.onVideoSeek(@{@"currentTime": [NSNumber numberWithFloat:CMTimeGetSeconds(item.currentTime)],

                               @"seekTime": [NSNumber numberWithFloat:seekTime],

                               @"seekTime": seekTime,

                               @"target": self.reactTag});

        }

      }];

  } else {

    // TODO: See if this makes sense and if so, actually implement it

    _pendingSeek = true;

    _pendingSeekTime = seekTime;

    _pendingSeekTime = [seekTime floatValue];

  }

}

RCT_EXPORT_VIEW_PROPERTY(playWhenInactive, BOOL);

RCT_EXPORT_VIEW_PROPERTY(ignoreSilentSwitch, NSString);

RCT_EXPORT_VIEW_PROPERTY(rate, float);

RCT_EXPORT_VIEW_PROPERTY(seek, float);

RCT_EXPORT_VIEW_PROPERTY(seek, NSDictionary);

RCT_EXPORT_VIEW_PROPERTY(currentTime, float);

RCT_EXPORT_VIEW_PROPERTY(fullscreen, BOOL);

RCT_EXPORT_VIEW_PROPERTY(progressUpdateInterval, float);