Optional<Integer> extract(TrackType trackType, int numberOfTracks, RendererTypeRequester typeRequester) { for (int i = 0; i < numberOfTracks; i++) { int rendererType = typeRequester.getRendererTypeFor(i); if ((trackType == TrackType.AUDIO && rendererType == C.TRACK_TYPE_AUDIO) || (trackType == TrackType.VIDEO && rendererType == C.TRACK_TYPE_VIDEO) || (trackType == TrackType.TEXT && rendererType == C.TRACK_TYPE_TEXT)) { return Optional.of(i); } } return Optional.absent(); } }
@Override public String toString() { return String.format("Optional<%s>", isAbsent() ? "Absent" : data.toString()); } }
TrackGroupArray trackGroups(TrackType trackType, RendererTypeRequester rendererTypeRequester) { Optional<Integer> audioRendererIndex = rendererTrackIndexExtractor.extract(trackType, mappedTrackInfoLength(), rendererTypeRequester); return audioRendererIndex.isAbsent() ? TrackGroupArray.EMPTY : trackInfo().getTrackGroups(audioRendererIndex.get()); }
@Test public void givenSubtitlesTrackAtPositionZero_whenExtractingTextIndex_thenReturnsIndexZero() { Optional<Integer> textIndex = extractor.extract(TrackType.TEXT, 1, rendererTypeRequesterTextTrack); int expectedTextIndex = 0; assertThat(textIndex.get()).isEqualTo(expectedTextIndex); }
Optional<PlayerVideoTrack> getSelectedVideoTrack() { assertIsInPlaybackState(); NoPlayerLog.w("Tried to get the currently playing video track but has not been implemented for MediaPlayer."); return Optional.absent(); }
public static NoPlayerExoPlayerCreator newInstance(Handler handler, DataSource.Factory dataSourceFactory) { InternalCreator internalCreator = new InternalCreator(handler, Optional.of(dataSourceFactory)); return new NoPlayerExoPlayerCreator(internalCreator); }
public boolean isAbsent() { return !isPresent(); }
public static <T> Optional<T> of(T data) { if (data == null) { throw new IllegalArgumentException("Data cannot be null. Use Optional.fromNullable(maybeNullData)."); } return new Optional<>(data); }
@Test public void givenThreeTrackTypes_whenExtractingAudioIndexes_thenReturnsIndexOne() { Optional<Integer> audioIndex = extractor.extract(TrackType.AUDIO, 3, rendererTypeRequesterVideoAudioTextTrack); int expectedAudioIndex = 1; assertThat(audioIndex.get()).isEqualTo(expectedAudioIndex); }
public static NoPlayerExoPlayerCreator newInstance(Handler handler) { InternalCreator internalCreator = new InternalCreator(handler, Optional.<DataSource.Factory>absent()); return new NoPlayerExoPlayerCreator(internalCreator); }
@Test public void whenGettingSelectedVideoTrack_thenDelegatesTrackSelector() { given(trackSelector.getSelectedVideoTrack(eq(exoPlayer), any(RendererTypeRequester.class), any(ContentType.class))).willReturn(Optional.of(PLAYER_VIDEO_TRACK)); Optional<PlayerVideoTrack> selectedVideoTrack = facade.getSelectedVideoTrack(); assertThat(selectedVideoTrack).isEqualTo(Optional.of(PLAYER_VIDEO_TRACK)); }
public Optional<T> or(Optional<T> elseCase) { return isPresent() ? this : elseCase; }
private DefaultDataSourceFactory createDataSourceFactory(DefaultBandwidthMeter bandwidthMeter) { if (dataSourceFactory.isPresent()) { return new DefaultDataSourceFactory(context, bandwidthMeter, dataSourceFactory.get()); } else { return new DefaultDataSourceFactory(context, "user-agent", bandwidthMeter); } }
@Test public void givenAudioTrackAtPositionZero_whenExtractingAudioIndex_thenReturnsIndexZero() { Optional<Integer> audioIndex = extractor.extract(TrackType.AUDIO, 1, rendererTypeRequesterAudioTrack); int expectedAudioIndex = 0; assertThat(audioIndex.get()).isEqualTo(expectedAudioIndex); }
@Test public void givenNoVideoTrack_whenExtractingVideoIndex_thenReturnsEmpty() { Optional<Integer> videoIndex = extractor.extract(TrackType.VIDEO, 1, emptyRendererTypeRequester); assertThat(videoIndex.isAbsent()).isTrue(); }
public Optional<PlayerVideoTrack> getSelectedVideoTrack(SimpleExoPlayer exoPlayer, RendererTypeRequester rendererTypeRequester, ContentType contentType) { Format selectedVideoFormat = exoPlayer.getVideoFormat(); if (selectedVideoFormat == null) { return Optional.absent(); } List<PlayerVideoTrack> videoTracks = getVideoTracks(rendererTypeRequester, contentType); return findSelectedVideoTrack(selectedVideoFormat, videoTracks); }
@Test public void givenTrackSelector_whenGettingCurrentlySelectedVideoTrack_thenReturnsSelectedTrack() { givenTrackSelectorContainsTracks(); given(exoPlayer.getVideoFormat()).willReturn(ADDITIONAL_VIDEO_FORMAT); Optional<PlayerVideoTrack> selectedVideoTrack = exoPlayerVideoTrackSelector.getSelectedVideoTrack(exoPlayer, rendererTypeRequester, ContentType.HLS); assertThat(selectedVideoTrack).isEqualTo(Optional.of(ADDITIONAL_PLAYER_VIDEO_TRACK)); }