| /* |
| * Copyright 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package androidx.media2.test.client.tests; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import android.media.AudioManager; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.ParcelFileDescriptor; |
| import android.support.v4.media.MediaMetadataCompat; |
| import android.support.v4.media.session.MediaControllerCompat; |
| import android.support.v4.media.session.MediaSessionCompat.QueueItem; |
| import android.support.v4.media.session.PlaybackStateCompat; |
| |
| import androidx.media.AudioAttributesCompat; |
| import androidx.media.VolumeProviderCompat; |
| import androidx.media2.common.FileMediaItem; |
| import androidx.media2.common.MediaItem; |
| import androidx.media2.common.MediaMetadata; |
| import androidx.media2.common.SessionPlayer; |
| import androidx.media2.session.MediaSession; |
| import androidx.media2.session.MediaUtils; |
| import androidx.media2.session.RemoteSessionPlayer; |
| import androidx.media2.test.client.MediaTestUtils; |
| import androidx.media2.test.client.RemoteMediaSession; |
| import androidx.media2.test.common.PollingCheck; |
| import androidx.media2.test.common.TestUtils; |
| import androidx.test.ext.junit.runners.AndroidJUnit4; |
| import androidx.test.filters.LargeTest; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| /** |
| * Tests for {@link MediaControllerCompat.Callback} with {@link MediaSession}. |
| */ |
| @RunWith(AndroidJUnit4.class) |
| @LargeTest |
| public class MediaControllerCompatCallbackWithMediaSessionTest extends MediaSessionTestBase { |
| private static final String TAG = "MCCCallbackTestWithMS2"; |
| |
| private static final long TIMEOUT_MS = 1000L; |
| private static final float EPSILON = 1e-6f; |
| |
| private RemoteMediaSession mSession; |
| private MediaControllerCompat mControllerCompat; |
| |
| @Before |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| mSession = new RemoteMediaSession(TAG, mContext, null); |
| mControllerCompat = new MediaControllerCompat(mContext, mSession.getCompatToken()); |
| } |
| |
| @After |
| @Override |
| public void cleanUp() throws Exception { |
| super.cleanUp(); |
| mSession.close(); |
| } |
| |
| @Test |
| public void repeatModeChange() throws Exception { |
| int testRepeatMode = SessionPlayer.REPEAT_MODE_GROUP; |
| |
| CountDownLatch latch = new CountDownLatch(1); |
| AtomicInteger repeatModeRef = new AtomicInteger(); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onRepeatModeChanged(int repeatMode) { |
| repeatModeRef.set(repeatMode); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setRepeatMode(testRepeatMode); |
| mSession.getMockPlayer().notifyRepeatModeChanged(); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testRepeatMode, repeatModeRef.get()); |
| assertEquals(testRepeatMode, mControllerCompat.getRepeatMode()); |
| } |
| |
| @Test |
| public void shuffleModeChange() throws Exception { |
| int testShuffleMode = SessionPlayer.SHUFFLE_MODE_GROUP; |
| |
| CountDownLatch latch = new CountDownLatch(1); |
| AtomicInteger shuffleModeRef = new AtomicInteger(); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onShuffleModeChanged(int shuffleMode) { |
| shuffleModeRef.set(shuffleMode); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setShuffleMode(testShuffleMode); |
| mSession.getMockPlayer().notifyShuffleModeChanged(); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testShuffleMode, shuffleModeRef.get()); |
| assertEquals(testShuffleMode, mControllerCompat.getShuffleMode()); |
| } |
| |
| @Test |
| public void close() throws Exception { |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onSessionDestroyed() { |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.close(); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| } |
| |
| @Test |
| public void updatePlayer() throws Exception { |
| int testState = SessionPlayer.PLAYER_STATE_PLAYING; |
| int testBufferingPosition = 1500; |
| float testSpeed = 1.5f; |
| List<MediaItem> testPlaylist = MediaTestUtils.createFileMediaItems(3); |
| int testItemIndex = 0; |
| String testPlaylistTitle = "testPlaylistTitle"; |
| MediaMetadata testPlaylistMetadata = new MediaMetadata.Builder() |
| .putText(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, testPlaylistTitle).build(); |
| |
| AtomicReference<PlaybackStateCompat> playbackStateRef = new AtomicReference<>(); |
| AtomicReference<MediaMetadataCompat> metadataRef = new AtomicReference<>(); |
| AtomicReference<CharSequence> queueTitleRef = new AtomicReference<>(); |
| CountDownLatch latchForPlaybackState = new CountDownLatch(1); |
| CountDownLatch latchForMetadata = new CountDownLatch(1); |
| CountDownLatch latchForQueue = new CountDownLatch(2); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onPlaybackStateChanged(PlaybackStateCompat state) { |
| playbackStateRef.set(state); |
| latchForPlaybackState.countDown(); |
| } |
| |
| @Override |
| public void onMetadataChanged(MediaMetadataCompat metadata) { |
| metadataRef.set(metadata); |
| latchForMetadata.countDown(); |
| } |
| |
| @Override |
| public void onQueueChanged(List<QueueItem> queue) { |
| latchForQueue.countDown(); |
| } |
| |
| @Override |
| public void onQueueTitleChanged(CharSequence title) { |
| queueTitleRef.set(title); |
| latchForQueue.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setPlayerState(testState) |
| .setBufferedPosition(testBufferingPosition) |
| .setPlaybackSpeed(testSpeed) |
| .setPlaylist(testPlaylist) |
| .setPlaylistMetadata(testPlaylistMetadata) |
| .setCurrentMediaItem(testPlaylist.get(testItemIndex)) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| |
| assertTrue(latchForPlaybackState.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testState, MediaUtils.convertToPlayerState(playbackStateRef.get())); |
| assertEquals(testBufferingPosition, playbackStateRef.get().getBufferedPosition()); |
| assertEquals(testSpeed, playbackStateRef.get().getPlaybackSpeed(), EPSILON); |
| |
| assertTrue(latchForMetadata.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testPlaylist.get(testItemIndex).getMediaId(), |
| metadataRef.get().getString(MediaMetadata.METADATA_KEY_MEDIA_ID)); |
| |
| assertTrue(latchForQueue.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| List<QueueItem> queue = mControllerCompat.getQueue(); |
| assertNotNull(queue); |
| assertEquals(testPlaylist.size(), queue.size()); |
| for (int i = 0; i < testPlaylist.size(); i++) { |
| assertEquals(testPlaylist.get(i).getMediaId(), |
| queue.get(i).getDescription().getMediaId()); |
| } |
| assertEquals(testPlaylistTitle, queueTitleRef.get().toString()); |
| } |
| |
| @Test |
| public void updatePlayer_playbackTypeChangedToRemote() throws Exception { |
| int controlType = VolumeProviderCompat.VOLUME_CONTROL_ABSOLUTE; |
| int maxVolume = 25; |
| int currentVolume = 10; |
| |
| AtomicReference<MediaControllerCompat.PlaybackInfo> infoRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo info) { |
| infoRef.set(info); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setVolumeControlType(controlType) |
| .setMaxVolume(maxVolume) |
| .setCurrentVolume(currentVolume) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_REMOTE, |
| infoRef.get().getPlaybackType()); |
| assertEquals(controlType, infoRef.get().getVolumeControl()); |
| assertEquals(maxVolume, infoRef.get().getMaxVolume()); |
| |
| MediaControllerCompat.PlaybackInfo info = mControllerCompat.getPlaybackInfo(); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_REMOTE, |
| info.getPlaybackType()); |
| assertEquals(controlType, info.getVolumeControl()); |
| assertEquals(maxVolume, info.getMaxVolume()); |
| assertEquals(currentVolume, info.getCurrentVolume()); |
| } |
| |
| @Test |
| public void updatePlayer_playbackTypeChangedToLocal() throws Exception { |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setVolumeControlType(VolumeProviderCompat.VOLUME_CONTROL_ABSOLUTE) |
| .setMaxVolume(10) |
| .setCurrentVolume(1) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| |
| int legacyStream = AudioManager.STREAM_RING; |
| AudioAttributesCompat attrs = new AudioAttributesCompat.Builder() |
| .setLegacyStreamType(legacyStream).build(); |
| |
| AtomicReference<MediaControllerCompat.PlaybackInfo> infoRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo info) { |
| infoRef.set(info); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| Bundle playerConfigToUpdate = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setPlaybackSpeed(1) |
| .setAudioAttributes(attrs) |
| .build(); |
| mSession.updatePlayer(playerConfigToUpdate); |
| |
| // In API 21 and 22, onAudioInfoChanged is not called when playback is changed to local. |
| if (Build.VERSION.SDK_INT == 21 || Build.VERSION.SDK_INT == 22) { |
| PollingCheck.waitFor(TIMEOUT_MS, |
| () -> mControllerCompat.getPlaybackInfo().getPlaybackType() |
| == MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL); |
| } else { |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL, |
| infoRef.get().getPlaybackType()); |
| assertEquals(legacyStream, infoRef.get().getAudioAttributes().getLegacyStreamType()); |
| } |
| |
| MediaControllerCompat.PlaybackInfo info = mControllerCompat.getPlaybackInfo(); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL, |
| info.getPlaybackType()); |
| assertEquals(legacyStream, info.getAudioAttributes().getLegacyStreamType()); |
| } |
| |
| @Test |
| public void updatePlayer_playbackTypeNotChanged_local() throws Exception { |
| int legacyStream = AudioManager.STREAM_RING; |
| AudioAttributesCompat attrs = new AudioAttributesCompat.Builder() |
| .setLegacyStreamType(legacyStream).build(); |
| |
| AtomicReference<MediaControllerCompat.PlaybackInfo> infoRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo info) { |
| infoRef.set(info); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setPlaybackSpeed(1) |
| .setAudioAttributes(attrs) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| |
| // In API 21+, onAudioInfoChanged() is not called when playbackType is not changed. |
| if (Build.VERSION.SDK_INT >= 21) { |
| PollingCheck.waitFor(TIMEOUT_MS, |
| () -> mControllerCompat.getPlaybackInfo().getPlaybackType() |
| == MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL); |
| } else { |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL, |
| infoRef.get().getPlaybackType()); |
| assertEquals(legacyStream, infoRef.get().getAudioAttributes().getLegacyStreamType()); |
| } |
| |
| MediaControllerCompat.PlaybackInfo info = mControllerCompat.getPlaybackInfo(); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_LOCAL, |
| info.getPlaybackType()); |
| assertEquals(legacyStream, info.getAudioAttributes().getLegacyStreamType()); |
| } |
| |
| @Test |
| public void updatePlayer_playbackTypeNotChanged_remote() throws Exception { |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setVolumeControlType(VolumeProviderCompat.VOLUME_CONTROL_ABSOLUTE) |
| .setMaxVolume(10) |
| .setCurrentVolume(1) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| |
| int controlType = VolumeProviderCompat.VOLUME_CONTROL_ABSOLUTE; |
| int maxVolume = 25; |
| int currentVolume = 10; |
| |
| AtomicReference<MediaControllerCompat.PlaybackInfo> infoRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo info) { |
| infoRef.set(info); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| Bundle playerConfigToUpdate = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setVolumeControlType(controlType) |
| .setMaxVolume(maxVolume) |
| .setCurrentVolume(currentVolume) |
| .build(); |
| mSession.updatePlayer(playerConfigToUpdate); |
| |
| // In API 21+, onAudioInfoChanged() is not called when playbackType is not changed. |
| if (Build.VERSION.SDK_INT >= 21) { |
| PollingCheck.waitFor(TIMEOUT_MS, |
| () -> mControllerCompat.getPlaybackInfo().getPlaybackType() |
| == MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_REMOTE); |
| } else { |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_REMOTE, |
| infoRef.get().getPlaybackType()); |
| assertEquals(controlType, infoRef.get().getVolumeControl()); |
| assertEquals(maxVolume, infoRef.get().getMaxVolume()); |
| assertEquals(currentVolume, infoRef.get().getCurrentVolume()); |
| } |
| |
| MediaControllerCompat.PlaybackInfo info = mControllerCompat.getPlaybackInfo(); |
| assertEquals(MediaControllerCompat.PlaybackInfo.PLAYBACK_TYPE_REMOTE, |
| info.getPlaybackType()); |
| assertEquals(controlType, info.getVolumeControl()); |
| assertEquals(maxVolume, info.getMaxVolume()); |
| assertEquals(currentVolume, info.getCurrentVolume()); |
| } |
| |
| @Test |
| public void playerStateChange() throws Exception { |
| int targetState = SessionPlayer.PLAYER_STATE_PLAYING; |
| |
| AtomicReference<PlaybackStateCompat> playbackStateRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(2); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onSessionReady() { |
| latch.countDown(); |
| } |
| |
| @Override |
| public void onPlaybackStateChanged(PlaybackStateCompat state) { |
| playbackStateRef.set(state); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().notifyPlayerStateChanged(targetState); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(targetState, MediaUtils.convertToPlayerState(playbackStateRef.get())); |
| assertEquals(targetState, |
| MediaUtils.convertToPlayerState(mControllerCompat.getPlaybackState())); |
| } |
| |
| @Test |
| public void playbackSpeedChange() throws Exception { |
| float speed = 1.5f; |
| |
| AtomicReference<PlaybackStateCompat> playbackStateRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onPlaybackStateChanged(PlaybackStateCompat state) { |
| playbackStateRef.set(state); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setPlaybackSpeed(speed); |
| mSession.getMockPlayer().notifyPlaybackSpeedChanged(speed); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(speed, playbackStateRef.get().getPlaybackSpeed(), EPSILON); |
| assertEquals(speed, mControllerCompat.getPlaybackState().getPlaybackSpeed(), EPSILON); |
| } |
| |
| @Test |
| public void bufferingStateChange() throws Exception { |
| List<MediaItem> testPlaylist = MediaTestUtils.createFileMediaItems(3); |
| int testItemIndex = 0; |
| int testBufferingState = SessionPlayer.BUFFERING_STATE_BUFFERING_AND_PLAYABLE; |
| long testBufferingPosition = 500; |
| mSession.getMockPlayer().setPlaylistWithDummyItem(testPlaylist); |
| |
| AtomicReference<PlaybackStateCompat> playbackStateRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onPlaybackStateChanged(PlaybackStateCompat state) { |
| playbackStateRef.set(state); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setBufferedPosition(testBufferingPosition); |
| mSession.getMockPlayer().notifyBufferingStateChanged(testItemIndex, testBufferingState); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testBufferingPosition, playbackStateRef.get().getBufferedPosition()); |
| assertEquals(testBufferingPosition, |
| mControllerCompat.getPlaybackState().getBufferedPosition()); |
| } |
| |
| @Test |
| public void seekComplete() throws Exception { |
| long testSeekPosition = 1300; |
| |
| AtomicReference<PlaybackStateCompat> playbackStateRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onPlaybackStateChanged(PlaybackStateCompat state) { |
| playbackStateRef.set(state); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setCurrentPosition(testSeekPosition); |
| mSession.getMockPlayer().setPlayerState(SessionPlayer.PLAYER_STATE_PAUSED); |
| mSession.getMockPlayer().notifySeekCompleted(testSeekPosition); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(testSeekPosition, playbackStateRef.get().getPosition()); |
| assertEquals(testSeekPosition, mControllerCompat.getPlaybackState().getPosition()); |
| } |
| |
| @Test |
| public void currentMediaItemChange() throws Exception { |
| String displayTitle = "displayTitle"; |
| MediaMetadata metadata = new MediaMetadata.Builder() |
| .putText(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, displayTitle).build(); |
| MediaItem currentMediaItem = new FileMediaItem.Builder(ParcelFileDescriptor.adoptFd(-1)) |
| .setMetadata(metadata) |
| .build(); |
| |
| List<MediaItem> playlist = MediaTestUtils.createFileMediaItems(5); |
| int testItemIndex = 3; |
| playlist.set(testItemIndex, currentMediaItem); |
| mSession.getMockPlayer().setPlaylistWithDummyItem(playlist); |
| |
| AtomicReference<MediaMetadataCompat> metadataRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onMetadataChanged(MediaMetadataCompat metadata) { |
| metadataRef.set(metadata); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setCurrentMediaItem(testItemIndex); |
| mSession.getMockPlayer().notifyCurrentMediaItemChanged(testItemIndex); |
| |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(displayTitle, |
| metadataRef.get().getString(MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE)); |
| assertEquals(displayTitle, |
| mControllerCompat.getMetadata().getString( |
| MediaMetadataCompat.METADATA_KEY_DISPLAY_TITLE)); |
| } |
| |
| @Test |
| public void playlistAndPlaylistMetadataChange() throws Exception { |
| List<MediaItem> playlist = MediaTestUtils.createFileMediaItems(5); |
| String playlistTitle = "playlistTitle"; |
| MediaMetadata playlistMetadata = new MediaMetadata.Builder() |
| .putText(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, playlistTitle).build(); |
| |
| AtomicReference<CharSequence> queueTitleRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(2); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onQueueChanged(List<QueueItem> queue) { |
| latch.countDown(); |
| } |
| |
| @Override |
| public void onQueueTitleChanged(CharSequence title) { |
| queueTitleRef.set(title); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setPlaylist(playlist); |
| mSession.getMockPlayer().setPlaylistMetadata(playlistMetadata); |
| mSession.getMockPlayer().notifyPlaylistChanged(); |
| |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| |
| List<QueueItem> queue = mControllerCompat.getQueue(); |
| assertNotNull(queue); |
| assertEquals(playlist.size(), queue.size()); |
| for (int i = 0; i < playlist.size(); i++) { |
| assertEquals(playlist.get(i).getMediaId(), queue.get(i).getDescription().getMediaId()); |
| } |
| assertEquals(playlistTitle, queueTitleRef.get().toString()); |
| } |
| |
| @Test |
| public void playlistAndPlaylistMetadataChange_longList() throws Exception { |
| String playlistTitle = "playlistTitle"; |
| MediaMetadata playlistMetadata = new MediaMetadata.Builder() |
| .putText(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, playlistTitle).build(); |
| |
| AtomicReference<CharSequence> queueTitleRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(2); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onQueueChanged(List<QueueItem> queue) { |
| latch.countDown(); |
| } |
| |
| @Override |
| public void onQueueTitleChanged(CharSequence title) { |
| queueTitleRef.set(title); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| int listSize = 5000; |
| mSession.getMockPlayer().createAndSetDummyPlaylist(listSize); |
| mSession.getMockPlayer().setPlaylistMetadata(playlistMetadata); |
| mSession.getMockPlayer().notifyPlaylistChanged(); |
| |
| assertTrue(latch.await(3, TimeUnit.SECONDS)); |
| |
| List<QueueItem> queue = mControllerCompat.getQueue(); |
| assertNotNull(queue); |
| |
| if (Build.VERSION.SDK_INT >= 21) { |
| assertEquals(listSize, queue.size()); |
| } else { |
| // Below API 21, only the initial part of the playlist is sent to the |
| // MediaControllerCompat when the list is too long. |
| assertTrue(queue.size() < listSize); |
| } |
| for (int i = 0; i < queue.size(); i++) { |
| assertEquals(TestUtils.getMediaIdInDummyList(i), |
| queue.get(i).getDescription().getMediaId()); |
| } |
| assertEquals(playlistTitle, queueTitleRef.get().toString()); |
| } |
| |
| @Test |
| public void playlistMetadataChange() throws Exception { |
| String playlistTitle = "playlistTitle"; |
| MediaMetadata playlistMetadata = new MediaMetadata.Builder() |
| .putText(MediaMetadata.METADATA_KEY_DISPLAY_TITLE, playlistTitle).build(); |
| |
| AtomicReference<CharSequence> queueTitleRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onQueueTitleChanged(CharSequence title) { |
| queueTitleRef.set(title); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| mSession.getMockPlayer().setPlaylistMetadata(playlistMetadata); |
| mSession.getMockPlayer().notifyPlaylistMetadataChanged(); |
| |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(playlistTitle, queueTitleRef.get().toString()); |
| } |
| |
| @Test |
| public void onAudioInfoChanged_isCalled_byVolumeChange() throws Exception { |
| if (!MediaTestUtils.isServiceToT()) { |
| // TODO(b/156594425): Remove this condition once the previous session becomes to notify |
| // volume changes of RemoteSessionPlayer (b/155059866). |
| return; |
| } |
| |
| Bundle playerConfig = new RemoteMediaSession.MockPlayerConfigBuilder() |
| .setVolumeControlType(RemoteSessionPlayer.VOLUME_CONTROL_ABSOLUTE) |
| .setMaxVolume(10) |
| .setCurrentVolume(1) |
| .build(); |
| mSession.updatePlayer(playerConfig); |
| |
| AtomicReference<MediaControllerCompat.PlaybackInfo> infoRef = new AtomicReference<>(); |
| CountDownLatch latch = new CountDownLatch(1); |
| MediaControllerCompat.Callback callback = new MediaControllerCompat.Callback() { |
| @Override |
| public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo info) { |
| infoRef.set(info); |
| latch.countDown(); |
| } |
| }; |
| mControllerCompat.registerCallback(callback, sHandler); |
| |
| int targetVolume = 3; |
| mSession.getMockPlayer().notifyVolumeChanged(targetVolume); |
| assertTrue(latch.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)); |
| assertEquals(targetVolume, infoRef.get().getCurrentVolume()); |
| } |
| } |