/*
 * Copyright (C) 2017 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.leanback.media;

import static android.support.test.InstrumentationRegistry.getContext;
import static android.support.test.InstrumentationRegistry.getInstrumentation;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.SdkSuppress;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.session.MediaControllerCompat;
import android.support.v4.media.session.MediaSessionCompat;
import android.support.v4.media.session.PlaybackStateCompat;

import androidx.leanback.widget.PlaybackControlsRow;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

/**
 * Test {@link MediaControllerAdapter}.
 */
@RunWith(AndroidJUnit4.class)
public class MediaControllerAdapterTest {

    // SESSION_TAG
    private static final String SESSION_TAG = "test-session";
    private final Object mWaitLock = new Object();
    private MediaSessionCompat mSession;
    private Handler mHandler = new Handler(Looper.getMainLooper());
    private MediaSessionCallback mCallback = new MediaSessionCallback();
    private MediaControllerCompat mControllerCompat;
    private MediaControllerAdapter mMediaControllerAdapter;
    private PlayerAdapterCallback mPlayerAdapterCallback;

    // Instrumented context for testing purpose
    private Context mContext;

    @Before
    public void setUp() throws Exception {
        mContext = InstrumentationRegistry.getInstrumentation().getContext();
        getInstrumentation().runOnMainSync(new Runnable() {
            @Override
            public void run() {
                mSession = new MediaSessionCompat(getContext(), SESSION_TAG);
                mSession.setCallback(mCallback, mHandler);
                mSession.setFlags(MediaSessionCompat.FLAG_HANDLES_QUEUE_COMMANDS);
                mControllerCompat = new MediaControllerCompat(mContext, mSession);
                mMediaControllerAdapter = new MediaControllerAdapter(mControllerCompat);
                mPlayerAdapterCallback = new PlayerAdapterCallback();
                mMediaControllerAdapter.setCallback(mPlayerAdapterCallback);
            }
        });
    }

    /**
     * Check if STATE_STOPPED is associated with onPlayComplete() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStateStopped() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_STOPPED));
            assertTrue(mPlayerAdapterCallback.mOnPlayCompletedCalled);
        }
    }

    /**
     * Check if STATE_PAUSED is associated with onPlaybackStateChanged() and
     * onCurrentPositionChanged() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStatePaused() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_PAUSED));
            assertTrue(mPlayerAdapterCallback.mOnPlayStateChangedCalled);
            assertTrue(mPlayerAdapterCallback.mOnCurrentPositionChangedCalled);
        }
    }

    /**
     * Check if STATE_PLAYING is associated with onPlaybackStateChanged() and
     * onCurrentPositionChanged() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStatePlaying() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_PLAYING));
            assertTrue(mPlayerAdapterCallback.mOnPlayStateChangedCalled);
            assertTrue(mPlayerAdapterCallback.mOnCurrentPositionChangedCalled);
        }
    }

    /**
     * Check if STATE_BUFFERING is associated with onBufferingStateChanged() and
     * onBufferedPositionChanged() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStateBuffering() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_BUFFERING));
            assertTrue(mPlayerAdapterCallback.mOnBufferingStateChangedCalled);
            assertTrue(mPlayerAdapterCallback.mOnBufferedPositionChangedCalled);
        }
    }

    /**
     * Check if STATE_ERROR is associated with onError() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStateError() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_ERROR));
            assertTrue(mPlayerAdapterCallback.mOnErrorCalled);
        }
    }

    /**
     * Check if STATE_FAST_FORWARDING is associated with onPlaybackStateChanged() and
     * onCurrentPositionChanged() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStateFastForwarding() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_FAST_FORWARDING));
            assertTrue(mPlayerAdapterCallback.mOnPlayStateChangedCalled);
            assertTrue(mPlayerAdapterCallback.mOnCurrentPositionChangedCalled);
        }
    }

    /**
     * Check if STATE_REWIND is associated with onPlaybackStateChanged() and
     * onCurrentPositionChanged() callback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testStateRewinding() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onPlaybackStateChanged(
                    createPlaybackStateForTesting(PlaybackStateCompat.STATE_REWINDING));
            assertTrue(mPlayerAdapterCallback.mOnPlayStateChangedCalled);
            assertTrue(mPlayerAdapterCallback.mOnCurrentPositionChangedCalled);
        }
    }

    /**
     * Check onMetadataChanged() function in PlayerAdapterCallback.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testOnMetadataChanged() {
        synchronized (mWaitLock) {
            mPlayerAdapterCallback.reset();
            mMediaControllerAdapter.mMediaControllerCallback.onMetadataChanged(
                    new MediaMetadataCompat.Builder().build());
            assertTrue(mPlayerAdapterCallback.mOnMetadataChangedCalled);
        }
    }

    /**
     * Check adapter's play operation.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testPlay() throws InterruptedException {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.play();
            mWaitLock.wait();
            assertTrue(mCallback.mOnPlayCalled);
        }
    }

    /**
     * Check adapter's pause operation.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testPause() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.pause();
            mWaitLock.wait();
            assertTrue(mCallback.mOnPauseCalled);
        }
    }

    /**
     * Check adapter's seekTo operation.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testSeekTo() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            long seekPosition = 445L;
            mMediaControllerAdapter.seekTo(seekPosition);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSeekToCalled);
            assertEquals(seekPosition, mCallback.mSeekPosition);
        }
    }

    /**
     * Check adapter's next operation.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testNext() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.next();
            mWaitLock.wait();
            assertTrue(mCallback.mOnSkipToNextCalled);
        }
    }

    /**
     * Check adapter's previous operation.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testPrevious() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.previous();
            mWaitLock.wait();
            assertTrue(mCallback.mOnSkipToPreviousCalled);
        }
    }

    /**
     * Check adapter's setRepeatAction operation.
     * In this test case, the repeat mode is set to REPEAT_MODE_NONE.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testRepeatModeRepeatModeNone() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.setRepeatAction(PlaybackControlsRow.RepeatAction.INDEX_NONE);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSetRepeatModeCalled);
            assertEquals(mCallback.mRepeatMode, PlaybackStateCompat.REPEAT_MODE_NONE);
        }
    }

    /**
     * Check adapter's setRepeatAction operation.
     * In this test case, the repeat mode is set to REPEAT_MODE_ONE.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testRepeatModeRepeatModeOne() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.setRepeatAction(PlaybackControlsRow.RepeatAction.INDEX_ONE);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSetRepeatModeCalled);
            assertEquals(mCallback.mRepeatMode, PlaybackStateCompat.REPEAT_MODE_ONE);
        }
    }

    /**
     * Check adapter's setRepeatAction operation.
     * In this test case, the repeat mode is set to REPEAT_MODE_ALL.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testRepeatModeRepeatModeAll() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.setRepeatAction(PlaybackControlsRow.RepeatAction.INDEX_ALL);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSetRepeatModeCalled);
            assertEquals(mCallback.mRepeatMode, PlaybackStateCompat.REPEAT_MODE_ALL);
        }
    }

    /**
     * Check adapter's setShuffleAction operation.
     * In this test case, the shuffle mode is set to SHUFFLE_MODE_NONE.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testShuffleModeShuffleModeNone() throws Exception {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.setShuffleAction(PlaybackControlsRow.ShuffleAction.INDEX_OFF);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSetShuffleModeCalled);
            assertEquals(mCallback.mShuffleMode, PlaybackStateCompat.SHUFFLE_MODE_NONE);
        }
    }

    /**
     * Check adapter's setShuffleAction operation.
     * In this test case, the shuffle mode is set to SHUFFLE_MODE_ALL.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testShuffleModeShuffleModeAll() throws InterruptedException {
        synchronized (mWaitLock) {
            mCallback.reset();
            mMediaControllerAdapter.setShuffleAction(PlaybackControlsRow.ShuffleAction.INDEX_ON);
            mWaitLock.wait();
            assertTrue(mCallback.mOnSetShuffleModeCalled);
            assertEquals(mCallback.mShuffleMode, PlaybackStateCompat.SHUFFLE_MODE_ALL);
        }
    }

    /**
     * Check adapter's isPlaying operation when the playState is null.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testIsPlayingWithNullPlaybackState() {
        boolean defualtIsPlayingStatus = false;
        assertEquals(mMediaControllerAdapter.isPlaying(), defualtIsPlayingStatus);
    }

    /**
     * Check adapter's isPlaying operation when the playback state is not null and the
     * media is playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testIsPlayingWithPlayingState() {
        long positionForTest = 0L;
        boolean playingStatus = true;
        createPlaybackStatePlaying(positionForTest);
        assertEquals(mMediaControllerAdapter.isPlaying(), playingStatus);
    }

    /**
     * Check adapter's isPlaying operation when the playback state is not null and the
     * media is not playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testIsPlayingWithNotPlayingState() {
        long positionForTest = 0L;
        boolean notPlayingStatus = false;
        createPlaybackStateNotPlaying(positionForTest);
        assertEquals(mMediaControllerAdapter.isPlaying(), notPlayingStatus);
    }

    /**
     * Check adapter's getCurrentPosition operation when the playbackState is null.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetCurrentPositionWithNullPlaybackState() {
        long defaultPosition = 0L;
        assertEquals(mMediaControllerAdapter.getCurrentPosition(), defaultPosition);
    }

    /**
     * Check adapter's getCurrentPosition operation when the playback state is not null and the
     * media is playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetCurrentPositionWithPlayingState() {

        long positionForTest = 445L;
        createPlaybackStatePlaying(positionForTest);
        assertTrue(mMediaControllerAdapter.getCurrentPosition() >= positionForTest);
    }

    /**
     * Check adapter's getBufferedPosition method when the playback state is not null and the
     * media is not playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetCurrentPositionWithNotPlayingState() {

        long positionForTest = 445L;
        createPlaybackStateNotPlaying(positionForTest);
        assertTrue(mMediaControllerAdapter.getCurrentPosition() == positionForTest);
    }

    /**
     * Check adapter's getBufferedPosition method when the playback state is null.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetBufferedPositionWithNullPlaybackState() {
        // TODO: considering chaning default buffered position to -1
        long defaultBufferedPosition = 0L;
        assertEquals(mMediaControllerAdapter.getBufferedPosition(), defaultBufferedPosition);
    }

    /**
     * Check adapter's getBufferedPosition method when the playback state is not null and the
     * media is playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetBufferedPositionWithPlayingState() {
        long positionForTest = 445L;
        createPlaybackStatePlayingWithBufferedPosition(positionForTest, positionForTest);
        assertEquals(mMediaControllerAdapter.getBufferedPosition(), positionForTest);
    }

    /**
     * Check adapter's getBufferedPosition method when the playback state is not null and the
     * media is not playing.
     *
     * @throws InterruptedException wait() operation may cause InterruptedException.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetBufferedPositionWithNotPlayingState() {
        long positionForTest = 445L;
        createPlaybackStateNotPlayingWithBufferedPosition(positionForTest, positionForTest);
        assertEquals(mMediaControllerAdapter.getBufferedPosition(), positionForTest);
    }

    /**
     * check adapter's getMediaTitle() operation when the media meta data is not null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaTitleWithValidMetaData() {
        int widthForTest = 1;
        int heightForTest = 1;
        Bitmap bitmapForTesting = Bitmap.createBitmap(widthForTest, heightForTest,
                Bitmap.Config.ARGB_8888);
        Long durationForTeting = 0L;
        String mediaTitle = "media title";
        String albumName = "album name";
        String artistName = "artist name";

        createMediaMetaData(bitmapForTesting, durationForTeting, mediaTitle, albumName, artistName);
        assertEquals(mMediaControllerAdapter.getMediaTitle(), mediaTitle);
    }

    /**
     * check adapter's getMediaTitle() operation when the media meta data is null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaTitleWithNullMetaData() {
        String defaultMediaTitle = "";
        assertEquals(mMediaControllerAdapter.getMediaTitle(), defaultMediaTitle);
    }

    /**
     * check adapter's getMediaSubtitle() operation when the media meta data is not null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaSubTitleWithValidMetaData() {
        int widthForTest = 1;
        int heightForTest = 1;
        Bitmap bitmapForTesting = Bitmap.createBitmap(widthForTest, heightForTest,
                Bitmap.Config.ARGB_8888);
        Long durationForTeting = 0L;
        String mediaTitle = "media title";
        String albumName = "album name";
        String artistName = "artist name";

        createMediaMetaData(bitmapForTesting, durationForTeting, mediaTitle, albumName, artistName);
        assertEquals(mMediaControllerAdapter.getMediaSubtitle(), albumName);
    }

    /**
     * check adapter's getMediaSubtitle() operation when the media meta data is null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaSubTitleWithNullMetaData() {
        String defaultMediaSubTitle = "";
        assertEquals(mMediaControllerAdapter.getMediaSubtitle(), defaultMediaSubTitle);
    }

    /**
     * check adapter's getMediaArt operation when the media meta data is not null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaArtWithValidMetaData() {
        int widthForTest = 1;
        int heightForTest = 1;
        Bitmap bitmapForTesting = Bitmap.createBitmap(widthForTest, heightForTest,
                Bitmap.Config.ARGB_8888);
        Long durationForTeting = 0L;
        String mediaTitle = "media title";
        String albumName = "album name";
        String artistName = "artist name";

        createMediaMetaData(bitmapForTesting, durationForTeting, mediaTitle, albumName, artistName);
        Drawable testDrawable = new BitmapDrawable(mContext.getResources(), bitmapForTesting);
        // compare two drawable objects through serveral selected fields.
        assertEquals(mMediaControllerAdapter.getMediaArt(mContext).getBounds(),
                testDrawable.getBounds());
        assertEquals(mMediaControllerAdapter.getMediaArt(mContext).getAlpha(),
                testDrawable.getAlpha());
        assertEquals(mMediaControllerAdapter.getMediaArt(mContext).getColorFilter(),
                testDrawable.getColorFilter());
    }

    /**
     * check adapter's getMediaArt operation when the media meta data is null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetMediaArtWithNullMetaData() {
        Bitmap defaultMediaArt = null;
        assertEquals(mMediaControllerAdapter.getMediaArt(mContext), defaultMediaArt);
    }

    /**
     * check adapter's getDuration operation when the media meta data is not null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetDurationWithValidMetaData() {
        int widthForTest = 1;
        int heightForTest = 1;
        Bitmap bitmapForTesting = Bitmap.createBitmap(widthForTest, heightForTest,
                Bitmap.Config.ARGB_8888);
        Long durationForTeting = 45L;
        String mediaTitle = "media title";
        String albumName = "album name";
        String artistName = "artist name";

        createMediaMetaData(bitmapForTesting, durationForTeting, mediaTitle, albumName, artistName);
        assertEquals((Long) mMediaControllerAdapter.getDuration(), durationForTeting);
    }

    /**
     * check adapter's getDuration operation when the media meta data is null.
     */
    @Test
    @SmallTest
    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
    public void testGetDurationWithNullMetaData() {
        Long defaultDuration = 0L;
        assertEquals((Long) mMediaControllerAdapter.getDuration(), defaultDuration);
    }

    @After
    public void tearDown() throws Exception {
        mSession.release();
    }

    /**
     * Helper function to create playback state in the situation where media is playing.
     *
     * @param position current media item's playing position.
     */
    private void createPlaybackStatePlaying(long position) {
        PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder();
        int playState = PlaybackStateCompat.STATE_PLAYING;
        long currentPosition = position;
        playbackStateBuilder.setState(playState, currentPosition, (float) 1.0).setActions(
                getPlaybackStateActions()
        );
        mSession.setPlaybackState(playbackStateBuilder.build());
    }

    /**
     * Helper function to create playback state in the situation where media is paused.
     *
     * @param position current media item's playing position.
     */
    private void createPlaybackStateNotPlaying(long position) {
        PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder();
        int playState = PlaybackStateCompat.STATE_PAUSED;
        long currentPosition = position;
        playbackStateBuilder.setState(playState, currentPosition, (float) 1.0).setActions(
                getPlaybackStateActions()
        );
        mSession.setPlaybackState(playbackStateBuilder.build());
    }

    /**
     * Helper function to create playback state in the situation that media is playing.
     * Also the buffered position will be assigned in this function.
     *
     * @param position         current media item's playing position.
     * @param bufferedPosition current media item's buffered position.
     */
    private void createPlaybackStatePlayingWithBufferedPosition(long position,
            long bufferedPosition) {
        PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder();
        int playState = PlaybackStateCompat.STATE_PLAYING;
        long currentPosition = position;
        playbackStateBuilder.setState(playState, currentPosition, (float) 1.0).setActions(
                getPlaybackStateActions()
        );
        playbackStateBuilder.setBufferedPosition(bufferedPosition);
        mSession.setPlaybackState(playbackStateBuilder.build());
    }

    /**
     * Helper function to create playback state in the situation that media is paused.
     * Also the buffered position will be assigned in this function.
     *
     * @param position         current media item's playing position.
     * @param bufferedPosition current media item's buffered position.
     */
    private void createPlaybackStateNotPlayingWithBufferedPosition(long position,
            long bufferedPosition) {
        PlaybackStateCompat.Builder playbackStateBuilder = new PlaybackStateCompat.Builder();
        int playState = PlaybackStateCompat.STATE_PLAYING;
        long currentPosition = position;
        playbackStateBuilder.setState(playState, currentPosition, (float) 1.0).setActions(
                getPlaybackStateActions()
        );
        playbackStateBuilder.setBufferedPosition(bufferedPosition);
        mSession.setPlaybackState(playbackStateBuilder.build());
    }

    /**
     * Helper function to compute the supported playback action.
     *
     * @return supported playback actions.
     */
    private long getPlaybackStateActions() {
        long res = PlaybackStateCompat.ACTION_PLAY
                | PlaybackStateCompat.ACTION_PAUSE
                | PlaybackStateCompat.ACTION_PLAY_PAUSE
                | PlaybackStateCompat.ACTION_SKIP_TO_NEXT
                | PlaybackStateCompat.ACTION_SKIP_TO_PREVIOUS
                | PlaybackStateCompat.ACTION_FAST_FORWARD
                | PlaybackStateCompat.ACTION_REWIND
                | PlaybackStateCompat.ACTION_SET_REPEAT_MODE
                | PlaybackStateCompat.ACTION_SET_SHUFFLE_MODE;
        return res;
    }

    /**
     * Helper function to create fake media meta data.
     *
     * @param bitmapForTesting   Bitmap
     * @param duratoinForTesting Duration
     * @param mediaTitle         Title.
     * @param albumName          Album name.
     * @param artistName         Artist name.
     */
    private void createMediaMetaData(Bitmap bitmapForTesting, Long duratoinForTesting,
            String mediaTitle, String albumName, String artistName) {
        MediaMetadataCompat.Builder metaDataBuilder = new MediaMetadataCompat.Builder();
        metaDataBuilder.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, duratoinForTesting);
        metaDataBuilder.putString(MediaMetadataCompat.METADATA_KEY_TITLE,
                mediaTitle);
        metaDataBuilder.putString(MediaMetadataCompat.METADATA_KEY_ALBUM,
                albumName);
        metaDataBuilder.putString(MediaMetadataCompat.METADATA_KEY_ARTIST,
                albumName);
        metaDataBuilder.putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART,
                bitmapForTesting);
        metaDataBuilder.putLong(MediaMetadataCompat.METADATA_KEY_DURATION,
                duratoinForTesting);
        mSession.setMetadata(metaDataBuilder.build());
    }

    // helper function to create dummy playback state for testing.
    PlaybackStateCompat createPlaybackStateForTesting(int playbackStateCompat) {
        long currentPosition = 0L;
        float playbackSpeed = 0.0f;
        PlaybackStateCompat.Builder builder = new PlaybackStateCompat.Builder();
        builder.setState(playbackStateCompat, currentPosition, playbackSpeed);
        return builder.build();
    }

    /**
     * Simulated MediaSessionCallback class for verification.
     */
    private class MediaSessionCallback extends MediaSessionCompat.Callback {
        private long mSeekPosition;
        private int mRepeatMode;
        private int mShuffleMode;

        private boolean mOnPlayCalled;
        private boolean mOnPauseCalled;
        private boolean mOnStopCalled;
        private boolean mOnFastForwardCalled;
        private boolean mOnRewindCalled;
        private boolean mOnSkipToPreviousCalled;
        private boolean mOnSkipToNextCalled;
        private boolean mOnSeekToCalled;
        private boolean mOnSetRepeatModeCalled;
        private boolean mOnSetShuffleModeCalled;

        public void reset() {
            mSeekPosition = -1;
            mRepeatMode = PlaybackStateCompat.REPEAT_MODE_NONE;
            mShuffleMode = PlaybackStateCompat.SHUFFLE_MODE_NONE;

            mOnPlayCalled = false;
            mOnPauseCalled = false;
            mOnStopCalled = false;
            mOnFastForwardCalled = false;
            mOnRewindCalled = false;
            mOnSkipToPreviousCalled = false;
            mOnSkipToNextCalled = false;
            mOnSeekToCalled = false;
            mOnSetRepeatModeCalled = false;
            mOnSetShuffleModeCalled = false;
        }

        @Override
        public void onPlay() {
            synchronized (mWaitLock) {
                mOnPlayCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onPause() {
            synchronized (mWaitLock) {
                mOnPauseCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onStop() {
            synchronized (mWaitLock) {
                mOnStopCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onFastForward() {
            synchronized (mWaitLock) {
                mOnFastForwardCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onRewind() {
            synchronized (mWaitLock) {
                mOnRewindCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onSkipToPrevious() {
            synchronized (mWaitLock) {
                mOnSkipToPreviousCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onSkipToNext() {
            synchronized (mWaitLock) {
                mOnSkipToNextCalled = true;
                mWaitLock.notify();
            }
        }

        @Override
        public void onSeekTo(long pos) {
            synchronized (mWaitLock) {
                mOnSeekToCalled = true;
                mSeekPosition = pos;
                mWaitLock.notify();
            }
        }

        @Override
        public void onSetShuffleMode(int shuffleMode) {
            synchronized (mWaitLock) {
                mOnSetShuffleModeCalled = true;
                mShuffleMode = shuffleMode;
                mWaitLock.notify();
            }
        }

        @Override
        public void onSetRepeatMode(int repeatMode) {
            synchronized (mWaitLock) {
                mOnSetRepeatModeCalled = true;
                mRepeatMode = repeatMode;
                mWaitLock.notify();
            }
        }
    }

    private class PlayerAdapterCallback extends PlayerAdapter.Callback {
        private boolean mOnPlayStateChangedCalled;
        private boolean mOnPreparedStateChangedCalled;
        private boolean mOnPlayCompletedCalled;
        private boolean mOnCurrentPositionChangedCalled;
        private boolean mOnBufferedPositionChangedCalled;
        private boolean mOnDurationChnagedCalled;
        private boolean mOnVideoSizeChangedCalled;
        private boolean mOnErrorCalled;
        private boolean mOnBufferingStateChangedCalled;
        private boolean mOnMetadataChangedCalled;

        public void reset() {
            mOnPlayStateChangedCalled = false;
            mOnPreparedStateChangedCalled = false;
            mOnPlayCompletedCalled = false;
            mOnCurrentPositionChangedCalled = false;
            mOnBufferedPositionChangedCalled = false;
            mOnDurationChnagedCalled = false;
            mOnVideoSizeChangedCalled = false;
            mOnErrorCalled = false;
            mOnBufferingStateChangedCalled = false;
            mOnMetadataChangedCalled = false;
        }

        @Override
        public void onPlayStateChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnPlayStateChangedCalled = true;
            }
        }

        @Override
        public void onPreparedStateChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnPreparedStateChangedCalled = true;
            }
        }

        @Override
        public void onPlayCompleted(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnPlayCompletedCalled = true;
            }
        }

        @Override
        public void onCurrentPositionChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnCurrentPositionChangedCalled = true;
            }
        }

        @Override
        public void onBufferedPositionChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnBufferedPositionChangedCalled = true;
            }
        }

        @Override
        public void onDurationChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnDurationChnagedCalled = true;
            }
        }

        @Override
        public void onVideoSizeChanged(PlayerAdapter adapter, int width, int height) {
            synchronized (mWaitLock) {
                mOnVideoSizeChangedCalled = true;
            }
        }

        @Override
        public void onError(PlayerAdapter adapter, int errorCode, String errorMessage) {
            synchronized (mWaitLock) {
                mOnErrorCalled = true;
            }
        }

        @Override
        public void onBufferingStateChanged(PlayerAdapter adapter, boolean start) {
            synchronized (mWaitLock) {
                mOnBufferingStateChangedCalled = true;
            }
        }

        @Override
        public void onMetadataChanged(PlayerAdapter adapter) {
            synchronized (mWaitLock) {
                mOnMetadataChangedCalled = true;
            }
        }
    }
}