How to use com.google.android.exoplayer2

private void resetRendererPosition(long periodPositionUs) throws ExoPlaybackException {
 rendererPositionUs =
   !queue.hasPlayingPeriod()
     ? periodPositionUs
     : queue.getPlayingPeriod().toRendererTime(periodPositionUs);
 mediaClock.resetPosition(rendererPositionUs);
 for (Renderer renderer : enabledRenderers) {
  renderer.resetPosition(rendererPositionUs);
 }
}

@Override
public long getDuration() {
 if (isPlayingAd()) {
  MediaPeriodId periodId = playbackInfo.periodId;
  playbackInfo.timeline.getPeriodByUid(periodId.periodUid, period);
  long adDurationUs = period.getAdDurationUs(periodId.adGroupIndex, periodId.adIndexInAdGroup);
  return C.usToMs(adDurationUs);
 }
 return getContentDuration();
}

private long periodPositionUsToWindowPositionMs(MediaPeriodId periodId, long positionUs) {
 long positionMs = C.usToMs(positionUs);
 playbackInfo.timeline.getPeriodByUid(periodId.periodUid, period);
 positionMs += period.getPositionInWindowMs();
 return positionMs;
}

/**
 * Creates a {@link SimpleExoPlayer} instance.
 *
 * @param context A {@link Context}.
 * @param trackSelector The {@link TrackSelector} that will be used by the instance.
 */
public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector) {
 return newSimpleInstance(context, new DefaultRenderersFactory(context), trackSelector);
}

@Override
public final long getContentDuration() {
 Timeline timeline = getCurrentTimeline();
 return timeline.isEmpty()
   ? C.TIME_UNSET
   : timeline.getWindow(getCurrentWindowIndex(), window).getDurationMs();
}

/**
 * Creates an {@link ExoPlayer} instance.
 *
 * @param renderers The {@link Renderer}s that will be used by the instance.
 * @param trackSelector The {@link TrackSelector} that will be used by the instance.
 */
public static ExoPlayer newInstance(Renderer[] renderers, TrackSelector trackSelector) {
 return newInstance(renderers, trackSelector, new DefaultLoadControl());
}

/** Creates a new media period queue. */
public MediaPeriodQueue() {
 period = new Timeline.Period();
 window = new Timeline.Window();
 timeline = Timeline.EMPTY;
}

@Override
public long getContentPosition() {
 if (isPlayingAd()) {
  playbackInfo.timeline.getPeriodByUid(playbackInfo.periodId.periodUid, period);
  return period.getPositionInWindowMs() + C.usToMs(playbackInfo.contentPositionUs);
 } else {
  return getCurrentPosition();
 }
}

@Override
public void setAuxEffectInfo(AuxEffectInfo auxEffectInfo) {
 verifyApplicationThread();
 for (Renderer renderer : renderers) {
  if (renderer.getTrackType() == C.TRACK_TYPE_AUDIO) {
   player
     .createMessage(renderer)
     .setType(C.MSG_SET_AUX_EFFECT_INFO)
     .setPayload(auxEffectInfo)
     .send();
  }
 }
}

private void stopInternal(boolean reset, boolean acknowledgeStop) {
 resetInternal(
   /* releaseMediaSource= */ true, /* resetPosition= */ reset, /* resetState= */ reset);
 playbackInfoUpdate.incrementPendingOperationAcks(
   pendingPrepareCount + (acknowledgeStop ? 1 : 0));
 pendingPrepareCount = 0;
 loadControl.onStopped();
 setState(Player.STATE_IDLE);
}

@Override
public int getCurrentPeriodIndex() {
 if (shouldMaskPosition()) {
  return maskingPeriodIndex;
 } else {
  return playbackInfo.timeline.getIndexOfPeriod(playbackInfo.periodId.periodUid);
 }
}

private void disableRenderer(Renderer renderer) throws ExoPlaybackException {
 mediaClock.onRendererDisabled(renderer);
 ensureStopped(renderer);
 renderer.disable();
}

@Override
public boolean dispatchSetRepeatMode(Player player, @RepeatMode int repeatMode) {
 player.setRepeatMode(repeatMode);
 return true;
}

private void startRenderers() throws ExoPlaybackException {
 rebuffering = false;
 mediaClock.start();
 for (Renderer renderer : enabledRenderers) {
  renderer.start();
 }
}

private void handleContinueLoadingRequested(MediaPeriod mediaPeriod) {
 if (!queue.isLoading(mediaPeriod)) {
  // Stale event.
  return;
 }
 queue.reevaluateBuffer(rendererPositionUs);
 maybeContinueLoading();
}

/**
 * Sets the {@link RepeatMode} and returns whether the repeat mode change has been fully handled.
 * If not, it is necessary to seek to the current playback position.
 */
public boolean updateRepeatMode(@RepeatMode int repeatMode) {
 this.repeatMode = repeatMode;
 return updateForPlaybackModeChange();
}

@Override
public int getRendererType(int index) {
 verifyApplicationThread();
 return player.getRendererType(index);
}

@Override
public int getCurrentWindowIndex() {
 verifyApplicationThread();
 return player.getCurrentWindowIndex();
}

@Override
public long getDuration() {
 verifyApplicationThread();
 return player.getDuration();
}

@Override
public long getBufferedPosition() {
 verifyApplicationThread();
 return player.getBufferedPosition();
}