How to use com.novoda.noplayer.model

  @Override
  public void apply(Consumer<L> leftConsumer, Consumer<R> rightConsumer) {
    leftConsumer.accept(valueLeft);
  }
}

  @Override
  public void onPrepared(PlayerState playerState) {
    loadTimeout.cancel();
  }
});

@Override
public byte[] getOfflineLicenseKeySetId() {
  return keySetIdToRestore.asBytes();
}

@Test
public void givenEitherContainsLeft_whenApplyingConsumers_thenRunsLeftConsumerWithCorrectValue() {
  String value = "foo";
  Either<String, Integer> either = Either.left(value);
  either.apply(leftConsumer, rightConsumer);
  verify(leftConsumer).accept(value);
}

  @Test
  public void givenEitherContainsRight_whenApplyingConsumers_thenRunsRightConsumerWithCorrectValue() {
    Integer value = 42;
    Either<String, Integer> either = Either.right(value);

    either.apply(leftConsumer, rightConsumer);

    verify(rightConsumer).accept(value);
  }
}

public void start(Timeout timeout, NoPlayer.LoadTimeoutCallback loadTimeoutCallback) {
  cancel();
  this.loadTimeoutCallback = loadTimeoutCallback;
  startTime = clock.getCurrentTime();
  endTime = startTime + timeout.inMillis();
  handler.post(loadTimeoutCheck);
}

@Override
public void loadVideoWithTimeout(Uri uri, Options options, Timeout timeout, LoadTimeoutCallback loadTimeoutCallback) {
  loadTimeout.start(timeout, loadTimeoutCallback);
  loadVideo(uri, options);
}

private void attachSurface(final MediaPlayer mediaPlayer, Either<Surface, SurfaceHolder> surface) {
  Either.Consumer<Surface> setSurface = new Either.Consumer<Surface>() {
    @Override
    public void accept(Surface value) {
      mediaPlayer.setSurface(value);
    }
  };
  Either.Consumer<SurfaceHolder> setDisplay = new Either.Consumer<SurfaceHolder>() {
    @Override
    public void accept(SurfaceHolder value) {
      mediaPlayer.setDisplay(value);
    }
  };
  surface.apply(setSurface, setDisplay);
}

  PlayerSubtitleTrack build() {
    return new PlayerSubtitleTrack(groupIndex, formatIndex, trackId, language, mimeType, numberOfChannels, frequency);
  }
}

  public PlayerVideoTrack build() {
    return new PlayerVideoTrack(groupIndex, formatIndex, id, contentType, width, height, fps, bitrate);
  }
}

  public PlayerAudioTrack build() {
    return new PlayerAudioTrack(
        groupIndex,
        formatIndex,
        trackId,
        language,
        mimeType,
        numberOfChannels,
        frequency,
        audioTrackType
    );
  }
}

public static Bitrate fromBitsPerSecond(long bitsPerSecond) {
  return new Bitrate(bitsPerSecond);
}

public static <L, R> Either<L, R> right(R right) {
  return new Right<>(right);
}

public static Timeout fromSeconds(long timeoutInSeconds) {
  return new Timeout(timeoutInSeconds * ONE_SECOND_IN_MILLIS);
}

public static <L, R> Either<L, R> left(L left) {
  return new Left<>(left);
}

public static PlayerAudioTrackFixture aPlayerAudioTrack() {
  return new PlayerAudioTrackFixture();
}

public static PlayerVideoTrackFixture aPlayerVideoTrack() {
  return new PlayerVideoTrackFixture();
}

  @Override
  public void apply(Consumer<L> leftConsumer, Consumer<R> rightConsumer) {
    rightConsumer.accept(valueRight);
  }
}

  @Override
  public void onPrepared(PlayerState playerState) {
    loadTimeout.cancel();
    mediaPlayer.setOnSeekCompleteListener(seekToResettingSeekListener);
  }
});

@Override
public void loadVideoWithTimeout(Uri uri, Options options, Timeout timeout, LoadTimeoutCallback loadTimeoutCallback) {
  loadTimeout.start(timeout, loadTimeoutCallback);
  loadVideo(uri, options);
}