supportv7/media/SampleMediaRouterActivity.java

/*
 * Copyright (C) 2013 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 com.example.android.supportv7.media;

import com.example.android.supportv7.R;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.BroadcastReceiver;
import android.content.res.Resources;
import android.content.DialogInterface;
import android.app.PendingIntent;
import android.app.Presentation;
import android.media.AudioManager;
import android.media.AudioManager.OnAudioFocusChangeListener;
import android.media.MediaMetadataRetriever;
import android.media.RemoteControlClient;
import android.net.Uri;
import android.os.Build;
import android.os.Handler;
import android.os.Bundle;
import android.os.SystemClock;
import android.support.v4.app.FragmentManager;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.ActionBarActivity;
import android.support.v7.app.MediaRouteActionProvider;
import android.support.v7.app.MediaRouteDiscoveryFragment;
import android.support.v7.media.MediaControlIntent;
import android.support.v7.media.MediaRouter;
import android.support.v7.media.MediaRouter.Callback;
import android.support.v7.media.MediaRouter.RouteInfo;
import android.support.v7.media.MediaRouter.ProviderInfo;
import android.support.v7.media.MediaRouteSelector;
import android.support.v7.media.MediaItemStatus;
import android.util.Log;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.Display;
import android.view.SurfaceView;
import android.view.SurfaceHolder;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.ImageButton;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.FrameLayout;
import android.widget.TabHost;
import android.widget.TabHost.TabSpec;
import android.widget.TabHost.OnTabChangeListener;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;


import java.io.File;

/**
 * <h3>Media Router Support Activity</h3>
 *
 * <p>
 * This demonstrates how to use the {@link MediaRouter} API to build an
 * application that allows the user to send content to various rendering
 * targets.
 * </p>
 */
public class SampleMediaRouterActivity extends ActionBarActivity {
    private static final String TAG = "MediaRouterSupport";
    private static final String DISCOVERY_FRAGMENT_TAG = "DiscoveryFragment";
    private static final String ACTION_STATUS_CHANGE =
            "com.example.android.supportv7.media.ACTION_STATUS_CHANGE";

    private MediaRouter mMediaRouter;
    private MediaRouteSelector mSelector;
    private LibraryAdapter mLibraryItems;
    private PlaylistAdapter mPlayListItems;
    private TextView mInfoTextView;
    private ListView mLibraryView;
    private ListView mPlayListView;
    private ImageButton mPauseResumeButton;
    private ImageButton mStopButton;
    private SeekBar mSeekBar;
    private String mStatsInfo;
    private boolean mPaused;
    private boolean mNeedResume;
    private boolean mSeeking;
    private long mLastStatusTime;
    private PlaylistAdapter mSavedPlaylist;

    private final Handler mHandler = new Handler();
    private final Runnable mUpdateSeekRunnable = new Runnable() {
        @Override
        public void run() {
            updateProgress(getCheckedMediaQueueItem());
            // update Ui every 1 second
            mHandler.postDelayed(this, 1000);
        }
    };

    private final MediaPlayerWrapper mMediaPlayer = new MediaPlayerWrapper(this);
    private final MediaPlayerWrapper.Callback mMediaPlayerCB =
            new MediaPlayerWrapper.Callback()  {
        @Override
        public void onError() {
            mPlayer.onFinish(true);
        }

        @Override
        public void onCompletion() {
            mPlayer.onFinish(false);
        }

        @Override
        public void onSizeChanged(int width, int height) {
            mPlayer.updateSize(width, height);
        }

        @Override
        public void onStatusChanged() {
            if (!mSeeking) {
                updateUi();
            }
        }
    };

    private final RemotePlayer mRemotePlayer = new RemotePlayer();
    private final LocalPlayer mLocalPlayer = new LocalPlayer();
    private Player mPlayer;
    private MediaSessionManager.Callback mPlayerCB;

    private final MediaRouter.Callback mMediaRouterCB = new MediaRouter.Callback() {
        // Return a custom callback that will simply log all of the route events
        // for demonstration purposes.
        @Override
        public void onRouteAdded(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteAdded: route=" + route);
        }

        @Override
        public void onRouteChanged(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteChanged: route=" + route);
            mPlayer.showStatistics();
        }

        @Override
        public void onRouteRemoved(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteRemoved: route=" + route);
        }

        @Override
        public void onRouteSelected(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteSelected: route=" + route);

            Player player = mPlayer;
            MediaSessionManager.Callback playerCB = mPlayerCB;

            if (route.supportsControlCategory(
                    MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
                Intent enqueueIntent = new Intent(MediaControlIntent.ACTION_ENQUEUE);
                enqueueIntent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
                enqueueIntent.setDataAndType(Uri.parse("http://"), "video/mp4");

                Intent removeIntent = new Intent(MediaControlIntent.ACTION_REMOVE);
                removeIntent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);

                // Remote Playback:
                //   If route supports remote queuing, let it manage the queue;
                //   otherwise, manage the queue locally and feed it one item at a time
                if (route.supportsControlRequest(enqueueIntent)
                 && route.supportsControlRequest(removeIntent)) {
                    player = mRemotePlayer;
                } else {
                    player = mLocalPlayer;
                }
                playerCB = mRemotePlayer;
                mRemotePlayer.reset();

            } else {
                // Local Playback:
                //   Use local player and feed media player one item at a time
                player = mLocalPlayer;
                playerCB = mMediaPlayer;
            }

            if (player != mPlayer || playerCB != mPlayerCB) {
                // save current playlist
                PlaylistAdapter playlist = new PlaylistAdapter();
                for (int i = 0; i < mPlayListItems.getCount(); i++) {
                    MediaQueueItem item = mPlayListItems.getItem(i);
                    if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
                            || item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
                        long position = item.getContentPosition();
                        long timeDelta = mPaused ? 0 :
                                (SystemClock.elapsedRealtime() - mLastStatusTime);
                        item.setContentPosition(position + timeDelta);
                    }
                    playlist.add(item);
                }

                // switch players
                mPlayer.stop();
                mPaused = false;
                mLocalPlayer.setCallback(playerCB);
                mPlayerCB = playerCB;
                mPlayer = player;
                mPlayer.showStatistics();
                mLocalPlayer.updatePresentation();

                // migrate playlist to new route
                int count = playlist.getCount();
                if (isRemoteQueue()) {
                    // if queuing is managed remotely, only enqueue the first
                    // item, as we need to have the returned session id to
                    // enqueue the rest of the playlist items
                    mSavedPlaylist = playlist;
                    count = 1;
                }
                for (int i = 0; i < count; i++) {
                    final MediaQueueItem item = playlist.getItem(i);
                    mPlayer.enqueue(item.getUri(), item.getContentPosition());
                }
            }
            updateUi();
        }

        @Override
        public void onRouteUnselected(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteUnselected: route=" + route);
            mPlayer.showStatistics();
        }

        @Override
        public void onRouteVolumeChanged(MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRouteVolumeChanged: route=" + route);
        }

        @Override
        public void onRoutePresentationDisplayChanged(
                MediaRouter router, RouteInfo route) {
            Log.d(TAG, "onRoutePresentationDisplayChanged: route=" + route);
        }

        @Override
        public void onProviderAdded(MediaRouter router, ProviderInfo provider) {
            Log.d(TAG, "onRouteProviderAdded: provider=" + provider);
        }

        @Override
        public void onProviderRemoved(MediaRouter router, ProviderInfo provider) {
            Log.d(TAG, "onRouteProviderRemoved: provider=" + provider);
        }

        @Override
        public void onProviderChanged(MediaRouter router, ProviderInfo provider) {
            Log.d(TAG, "onRouteProviderChanged: provider=" + provider);
        }
    };

    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "Received status update: " + intent);
            if (intent.getAction().equals(ACTION_STATUS_CHANGE)) {
                String sid = intent.getStringExtra(MediaControlIntent.EXTRA_SESSION_ID);
                String iid = intent.getStringExtra(MediaControlIntent.EXTRA_ITEM_ID);
                MediaItemStatus status = MediaItemStatus.fromBundle(
                    intent.getBundleExtra(MediaControlIntent.EXTRA_ITEM_STATUS));

                if (status.getPlaybackState() ==
                        MediaItemStatus.PLAYBACK_STATE_FINISHED) {
                    mPlayer.onFinish(false);
                } else if (status.getPlaybackState() ==
                        MediaItemStatus.PLAYBACK_STATE_ERROR) {
                    mPlayer.onFinish(true);
                    showToast("Error while playing item" +
                            ", sid " + sid + ", iid " + iid);
                } else {
                    if (!mSeeking) {
                        updateUi();
                    }
                }
            }
        }
    };

    private RemoteControlClient mRemoteControlClient;
    private ComponentName mEventReceiver;
    private AudioManager mAudioManager;
    private PendingIntent mMediaPendingIntent;
    private final OnAudioFocusChangeListener mAfChangeListener =
            new OnAudioFocusChangeListener() {
        @Override
        public void onAudioFocusChange(int focusChange) {
            if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT) {
                Log.d(TAG, "onAudioFocusChange: LOSS_TRANSIENT");
            } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
                Log.d(TAG, "onAudioFocusChange: AUDIOFOCUS_GAIN");
            } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
                Log.d(TAG, "onAudioFocusChange: AUDIOFOCUS_LOSS");
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Be sure to call the super class.
        super.onCreate(savedInstanceState);

        // Get the media router service.
        mMediaRouter = MediaRouter.getInstance(this);

        // Create a route selector for the type of routes that we care about.
        mSelector = new MediaRouteSelector.Builder()
                .addControlCategory(MediaControlIntent.CATEGORY_LIVE_AUDIO)
                .addControlCategory(MediaControlIntent.CATEGORY_LIVE_VIDEO)
                .addControlCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)
                .addControlCategory(SampleMediaRouteProvider.CATEGORY_SAMPLE_ROUTE)
                .build();

        // Add a fragment to take care of media route discovery.
        // This fragment automatically adds or removes a callback whenever the activity
        // is started or stopped.
        FragmentManager fm = getSupportFragmentManager();
        DiscoveryFragment fragment = (DiscoveryFragment)fm.findFragmentByTag(
                DISCOVERY_FRAGMENT_TAG);
        if (fragment == null) {
            fragment = new DiscoveryFragment(mMediaRouterCB);
            fragment.setRouteSelector(mSelector);
            fm.beginTransaction()
                    .add(fragment, DISCOVERY_FRAGMENT_TAG)
                    .commit();
        } else {
            fragment.setCallback(mMediaRouterCB);
            fragment.setRouteSelector(mSelector);
        }

        // Populate an array adapter with streaming media items.
        String[] mediaNames = getResources().getStringArray(R.array.media_names);
        String[] mediaUris = getResources().getStringArray(R.array.media_uris);
        mLibraryItems = new LibraryAdapter();
        for (int i = 0; i < mediaNames.length; i++) {
            mLibraryItems.add(new MediaItem(
                    "[streaming] "+mediaNames[i], Uri.parse(mediaUris[i])));
        }

        // Scan local /sdcard/ directory for media files.
        String sdcard = "/sdcard/";
        File file = new File(sdcard);
        File list[] = file.listFiles();
        for (int i = 0; i < list.length; i++) {
            String filename = list[i].getName();
            if (filename.matches(".*\\.(m4v|mp4)")) {
                mLibraryItems.add(new MediaItem(
                        "[local] "+filename, Uri.parse("file:///sdcard/" + filename)));
            }
        }

        mPlayListItems = new PlaylistAdapter();

        // Initialize the layout.
        setContentView(R.layout.sample_media_router);

        TabHost tabHost=(TabHost)findViewById(R.id.tabHost);
        tabHost.setup();
        String tabName = getResources().getString(R.string.library_tab_text);
        TabSpec spec1=tabHost.newTabSpec(tabName);
        spec1.setContent(R.id.tab1);
        spec1.setIndicator(tabName);

        tabName = getResources().getString(R.string.playlist_tab_text);
        TabSpec spec2=tabHost.newTabSpec(tabName);
        spec2.setIndicator(tabName);
        spec2.setContent(R.id.tab2);

        tabName = getResources().getString(R.string.statistics_tab_text);
        TabSpec spec3=tabHost.newTabSpec(tabName);
        spec3.setIndicator(tabName);
        spec3.setContent(R.id.tab3);

        tabHost.addTab(spec1);
        tabHost.addTab(spec2);
        tabHost.addTab(spec3);
        tabHost.setOnTabChangedListener(new OnTabChangeListener() {
            @Override
            public void onTabChanged(String arg0) {
                if (arg0.equals(getResources().getString(
                        R.string.statistics_tab_text))) {
                    mPlayer.showStatistics();
                }
                updateUi();
            }
        });

        mLibraryView = (ListView) findViewById(R.id.media);
        mLibraryView.setAdapter(mLibraryItems);
        mLibraryView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
        mLibraryView.setOnItemClickListener(new OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                updateButtons();
            }
        });

        mPlayListView = (ListView) findViewById(R.id.playlist);
        mPlayListView.setAdapter(mPlayListItems);
        mPlayListView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
        mPlayListView.setOnItemClickListener(new OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                updateButtons();
            }
        });

        mInfoTextView = (TextView) findViewById(R.id.info);

        mPauseResumeButton = (ImageButton)findViewById(R.id.pause_resume_button);
        mPauseResumeButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                if (!mPaused) {
                    mPlayer.pause();
                } else {
                    mPlayer.resume();
                }
            }
        });

        mStopButton = (ImageButton)findViewById(R.id.stop_button);
        mStopButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                mPlayer.stop();
                clearContent();
            }
        });

        mSeekBar = (SeekBar) findViewById(R.id.seekbar);
        mSeekBar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                MediaQueueItem item = getCheckedMediaQueueItem();
                if (fromUser && item != null && item.getContentDuration() > 0) {
                    long pos = progress * item.getContentDuration() / 100;
                    mPlayer.seek(item.getSessionId(), item.getItemId(), pos);
                    item.setContentPosition(pos);
                    mLastStatusTime = SystemClock.elapsedRealtime();
                }
            }
            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
                mSeeking = true;
            }
            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
                mSeeking = false;
                updateUi();
            }
        });

        // Schedule Ui update
        mHandler.postDelayed(mUpdateSeekRunnable, 1000);

        // Use local playback with media player by default
        mLocalPlayer.onCreate();
        mMediaPlayer.setCallback(mMediaPlayerCB);
        mLocalPlayer.setCallback(mMediaPlayer);
        mPlayerCB = mMediaPlayer;
        mPlayer = mLocalPlayer;

        // Register broadcast receiver to receive status update from MRP
        IntentFilter filter = new IntentFilter();
        filter.addAction(SampleMediaRouterActivity.ACTION_STATUS_CHANGE);
        registerReceiver(mReceiver, filter);

        // Build the PendingIntent for the remote control client
        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        mEventReceiver = new ComponentName(getPackageName(),
                SampleMediaButtonReceiver.class.getName());
        Intent mediaButtonIntent = new Intent(Intent.ACTION_MEDIA_BUTTON);
        mediaButtonIntent.setComponent(mEventReceiver);
        mMediaPendingIntent = PendingIntent.getBroadcast(this, 0, mediaButtonIntent, 0);

        // Create and register the remote control client
        registerRCC();
    }

    private void registerRCC() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
            // Create the RCC and register with AudioManager and MediaRouter
            mAudioManager.requestAudioFocus(mAfChangeListener,
                    AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
            mAudioManager.registerMediaButtonEventReceiver(mEventReceiver);
            mRemoteControlClient = new RemoteControlClient(mMediaPendingIntent);
            mAudioManager.registerRemoteControlClient(mRemoteControlClient);
            mMediaRouter.addRemoteControlClient(mRemoteControlClient);
            SampleMediaButtonReceiver.setActivity(SampleMediaRouterActivity.this);
            mRemoteControlClient.setTransportControlFlags(
                    RemoteControlClient.FLAG_KEY_MEDIA_PLAY_PAUSE);
            mRemoteControlClient.setPlaybackState(
                    RemoteControlClient.PLAYSTATE_PLAYING);
        }
    }

    private void unregisterRCC() {
        // Unregister the RCC with AudioManager and MediaRouter
        if (mRemoteControlClient != null) {
            mRemoteControlClient.setTransportControlFlags(0);
            mAudioManager.abandonAudioFocus(mAfChangeListener);
            mAudioManager.unregisterMediaButtonEventReceiver(mEventReceiver);
            mAudioManager.unregisterRemoteControlClient(mRemoteControlClient);
            mMediaRouter.removeRemoteControlClient(mRemoteControlClient);
            SampleMediaButtonReceiver.setActivity(null);
            mRemoteControlClient = null;
        }
    }

    public boolean handleMediaKey(KeyEvent event) {
        if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) {
            switch (event.getKeyCode()) {
                case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                {
                    Log.d(TAG, "Received Play/Pause event from RemoteControlClient");
                    if (!mPaused) {
                        mPlayer.pause();
                    } else {
                        mPlayer.resume();
                    }
                    return true;
                }
                case KeyEvent.KEYCODE_MEDIA_PLAY:
                {
                    Log.d(TAG, "Received Play event from RemoteControlClient");
                    if (mPaused) {
                        mPlayer.resume();
                    }
                    return true;
                }
                case KeyEvent.KEYCODE_MEDIA_PAUSE:
                {
                    Log.d(TAG, "Received Pause event from RemoteControlClient");
                    if (!mPaused) {
                        mPlayer.pause();
                    }
                    return true;
                }
                case KeyEvent.KEYCODE_MEDIA_STOP:
                {
                    Log.d(TAG, "Received Stop event from RemoteControlClient");
                    mPlayer.stop();
                    clearContent();
                    return true;
                }
                default:
                    break;
            }
        }
        return false;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return handleMediaKey(event) || super.onKeyDown(keyCode, event);
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        return handleMediaKey(event) || super.onKeyUp(keyCode, event);
    }

    @Override
    public void onStart() {
        // Be sure to call the super class.
        super.onStart();
        mPlayer.showStatistics();
    }

    @Override
    public void onPause() {
        // pause media player for local playback case only
        if (!isRemotePlayback() && !mPaused) {
            mNeedResume = true;
            mPlayer.pause();
        }
        super.onPause();
    }

    @Override
    public void onResume() {
        // resume media player for local playback case only
        if (!isRemotePlayback() && mNeedResume) {
            mPlayer.resume();
            mNeedResume = false;
        }
        super.onResume();
    }

    @Override
    public void onDestroy() {
        // Unregister the remote control client
        unregisterRCC();

        // Unregister broadcast receiver
        unregisterReceiver(mReceiver);
        mPlayer.stop();
        mMediaPlayer.release();

        super.onDestroy();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Be sure to call the super class.
        super.onCreateOptionsMenu(menu);

        // Inflate the menu and configure the media router action provider.
        getMenuInflater().inflate(R.menu.sample_media_router_menu, menu);

        MenuItem mediaRouteMenuItem = menu.findItem(R.id.media_route_menu_item);
        MediaRouteActionProvider mediaRouteActionProvider =
                (MediaRouteActionProvider)MenuItemCompat.getActionProvider(mediaRouteMenuItem);
        mediaRouteActionProvider.setRouteSelector(mSelector);

        // Return true to show the menu.
        return true;
    }

    private void updateRouteDescription() {
        RouteInfo route = mMediaRouter.getSelectedRoute();
        mInfoTextView.setText("Currently selected route:"
                + "\nName: " + route.getName()
                + "\nProvider: " + route.getProvider().getPackageName()
                + "\nDescription: " + route.getDescription()
                + "\nStatistics: " + mStatsInfo);
        updateButtons();
        mLocalPlayer.updatePresentation();
    }

    private void clearContent() {
        //TO-DO: clear surface view
    }

    private void updateButtons() {
        MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
        // show pause or resume icon depending on current state
        mPauseResumeButton.setImageResource(mPaused ?
                R.drawable.ic_media_play : R.drawable.ic_media_pause);
        // only enable seek bar when duration is known
        MediaQueueItem item = getCheckedMediaQueueItem();
        mSeekBar.setEnabled(item != null && item.getContentDuration() > 0);
        if (mRemoteControlClient != null) {
            mRemoteControlClient.setPlaybackState(mPaused ?
                    RemoteControlClient.PLAYSTATE_PAUSED : RemoteControlClient.PLAYSTATE_PLAYING);
        }
    }

    private void updateProgress(MediaQueueItem queueItem) {
        // Estimate content position from last status time and elapsed time.
        // (Note this might be slightly out of sync with remote side, however
        // it avoids frequent polling the MRP.)
        int progress = 0;
        if (queueItem != null) {
            int state = queueItem.getState();
            long duration = queueItem.getContentDuration();
            if (duration <= 0) {
                if (state == MediaItemStatus.PLAYBACK_STATE_PLAYING
                        || state == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
                    updateUi();
                }
            } else {
                long position = queueItem.getContentPosition();
                long timeDelta = mPaused ? 0 :
                        (SystemClock.elapsedRealtime() - mLastStatusTime);
                progress = (int)(100.0 * (position + timeDelta) / duration);
            }
        }
        mSeekBar.setProgress(progress);
    }

    private void updateUi() {
        updatePlaylist();
        updateButtons();
    }

    private void updatePlaylist() {
        Log.d(TAG, "updatePlaylist");
        final PlaylistAdapter playlist = new PlaylistAdapter();
        // make a copy of current playlist
        for (int i = 0; i < mPlayListItems.getCount(); i++) {
            playlist.add(mPlayListItems.getItem(i));
        }
        // clear mPlayListItems first, items will be added back when we get
        // status back from provider.
        mPlayListItems.clear();
        mPlayListView.invalidate();

        for (int i = 0; i < playlist.getCount(); i++) {
            final MediaQueueItem item = playlist.getItem(i);
            final boolean update = (i == playlist.getCount() - 1);
            mPlayer.getStatus(item, update);
        }
    }

    private MediaItem getCheckedMediaItem() {
        int index = mLibraryView.getCheckedItemPosition();
        if (index >= 0 && index < mLibraryItems.getCount()) {
            return mLibraryItems.getItem(index);
        }
        return null;
    }

    private MediaQueueItem getCheckedMediaQueueItem() {
        int count = mPlayListView.getCount();
        int index = mPlayListView.getCheckedItemPosition();
        if (count > 0) {
            if (index < 0 || index >= count) {
                index = 0;
                mPlayListView.setItemChecked(0, true);
            }
            return mPlayListItems.getItem(index);
        }
        return null;
    }

    private void enqueuePlaylist() {
        if (mSavedPlaylist != null) {
            final PlaylistAdapter playlist = mSavedPlaylist;
            mSavedPlaylist = null;
            // migrate playlist (except for the 1st item) to new route
            for (int i = 1; i < playlist.getCount(); i++) {
                final MediaQueueItem item = playlist.getItem(i);
                mPlayer.enqueue(item.getUri(), item.getContentPosition());
            }
        }
    }

    private boolean isRemoteQueue() {
        return mPlayer == mRemotePlayer;
    }

    private boolean isRemotePlayback() {
        return mPlayerCB == mRemotePlayer;
    }

    private void showToast(String msg) {
        Toast toast = Toast.makeText(SampleMediaRouterActivity.this,
                "[app] " + msg, Toast.LENGTH_LONG);
        toast.setGravity(Gravity.TOP, 0, 100);
        toast.show();
    }

    private interface Player {
        void enqueue(final Uri uri, long pos);
        void remove(final MediaQueueItem item);
        void seek(String sid, String iid, long pos);
        void getStatus(final MediaQueueItem item, final boolean update);
        void pause();
        void resume();
        void stop();
        void showStatistics();
        void onFinish(boolean error);
        void updateSize(int width, int height);
    }

    private class LocalPlayer implements Player, SurfaceHolder.Callback {
        private final MediaSessionManager mSessionManager = new MediaSessionManager();
        private String mSessionId;
        // The presentation to show on the secondary display.
        private DemoPresentation mPresentation;
        private SurfaceView mSurfaceView;
        private FrameLayout mLayout;
        private int mVideoWidth;
        private int mVideoHeight;

        public void onCreate() {
            mLayout = (FrameLayout)findViewById(R.id.player);
            mSurfaceView = (SurfaceView)findViewById(R.id.surface_view);
            SurfaceHolder holder = mSurfaceView.getHolder();
            holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
            holder.addCallback(this);
        }

        public void setCallback(MediaSessionManager.Callback cb) {
            mSessionManager.setCallback(cb);
        }

        @Override
        public void enqueue(final Uri uri, long pos) {
            Log.d(TAG, "LocalPlayer: enqueue, uri=" + uri + ", pos=" + pos);
            MediaQueueItem playlistItem = mSessionManager.enqueue(mSessionId, uri, null);
            mSessionId = playlistItem.getSessionId();
            // Set remote control client title
            if (mPlayListItems.getCount() == 0 && mRemoteControlClient != null) {
                RemoteControlClient.MetadataEditor ed = mRemoteControlClient.editMetadata(true);
                ed.putString(MediaMetadataRetriever.METADATA_KEY_TITLE,
                        playlistItem.toString());
                ed.apply();
            }
            mPlayListItems.add(playlistItem);
            if (pos > 0) {
                // Seek to initial position if needed
                mPlayer.seek(mSessionId, playlistItem.getItemId(), pos);
            }
            updateUi();
        }

        @Override
        public void remove(final MediaQueueItem item) {
            Log.d(TAG, "LocalPlayer: remove, item=" + item);
            mSessionManager.remove(item.getSessionId(), item.getItemId());
            updateUi();
        }

        @Override
        public void seek(String sid, String iid, long pos) {
            Log.d(TAG, "LocalPlayer: seek, sid=" + sid + ", iid=" + iid);
            mSessionManager.seek(sid, iid, pos);
        }

        @Override
        public void getStatus(final MediaQueueItem item, final boolean update) {
            Log.d(TAG, "LocalPlayer: getStatus, item=" + item + ", update=" + update);
            MediaQueueItem playlistItem =
                    mSessionManager.getStatus(item.getSessionId(), item.getItemId());
            if (playlistItem != null) {
                mLastStatusTime = playlistItem.getStatus().getTimestamp();
                mPlayListItems.add(item);
                mPlayListView.invalidate();
            }
            if (update) {
                clearContent();
                updateButtons();
            }
        }

        @Override
        public void pause() {
            Log.d(TAG, "LocalPlayer: pause");
            mSessionManager.pause(mSessionId);
            mPaused = true;
            updateUi();
        }

        @Override
        public void resume() {
            Log.d(TAG, "LocalPlayer: resume");
            mSessionManager.resume(mSessionId);
            mPaused = false;
            updateUi();
        }

        @Override
        public void stop() {
            Log.d(TAG, "LocalPlayer: stop");
            mSessionManager.stop(mSessionId);
            mSessionId = null;
            mPaused = false;
            // For demo purpose, invalidate remote session when local session
            // is stopped (note this is not necessary, remote player could reuse
            // the same session)
            mRemotePlayer.reset();
            updateUi();
        }

        @Override
        public void showStatistics() {
            Log.d(TAG, "LocalPlayer: showStatistics");
            mStatsInfo = null;
            if (isRemotePlayback()) {
                mRemotePlayer.showStatistics();
            }
            updateRouteDescription();
        }

        @Override
        public void onFinish(boolean error) {
            MediaQueueItem item = mSessionManager.finish(error);
            updateUi();
            if (error && item != null) {
                showToast("Failed to play item " + item.getUri());
            }
        }

        // SurfaceHolder.Callback
        @Override
        public void surfaceChanged(SurfaceHolder holder, int format,
                int width, int height) {
            Log.d(TAG, "surfaceChanged "+width+"x"+height);
            mMediaPlayer.setSurface(holder);
        }

        @Override
        public void surfaceCreated(SurfaceHolder holder) {
            Log.d(TAG, "surfaceCreated");
            mMediaPlayer.setSurface(holder);
            updateSize(mVideoWidth, mVideoHeight);
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
            Log.d(TAG, "surfaceDestroyed");
        }

        @Override
        public void updateSize(int width, int height) {
            if (width > 0 && height > 0) {
                if (mPresentation == null) {
                    int surfaceWidth = mLayout.getWidth();
                    int surfaceHeight = mLayout.getHeight();

                    // Calculate the new size of mSurfaceView, so that video is centered
                    // inside the framelayout with proper letterboxing/pillarboxing
                    ViewGroup.LayoutParams lp = mSurfaceView.getLayoutParams();
                    if (surfaceWidth * height < surfaceHeight * width) {
                        // Black bars on top&bottom, mSurfaceView has full layout width,
                        // while height is derived from video's aspect ratio
                        lp.width = surfaceWidth;
                        lp.height = surfaceWidth * height / width;
                    } else {
                        // Black bars on left&right, mSurfaceView has full layout height,
                        // while width is derived from video's aspect ratio
                        lp.width = surfaceHeight * width / height;
                        lp.height = surfaceHeight;
                    }
                    Log.d(TAG, "video rect is "+lp.width+"x"+lp.height);
                    mSurfaceView.setLayoutParams(lp);
                } else {
                    mPresentation.updateSize(width, height);
                }
                mVideoWidth = width;
                mVideoHeight = height;
            } else {
                mVideoWidth = mVideoHeight = 0;
            }
        }

        private void updatePresentation() {
            // Get the current route and its presentation display.
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Display presentationDisplay = route != null ? route.getPresentationDisplay() : null;

            // Dismiss the current presentation if the display has changed.
            if (mPresentation != null && mPresentation.getDisplay() != presentationDisplay) {
                Log.i(TAG, "Dismissing presentation because the current route no longer "
                        + "has a presentation display.");
                mPresentation.dismiss();
                mPresentation = null;
            }

            // Show a new presentation if needed.
            if (mPresentation == null && presentationDisplay != null) {
                Log.i(TAG, "Showing presentation on display: " + presentationDisplay);
                mPresentation = new DemoPresentation(
                        SampleMediaRouterActivity.this, presentationDisplay);
                mPresentation.setOnDismissListener(mOnDismissListener);
                try {
                    mPresentation.show();
                } catch (WindowManager.InvalidDisplayException ex) {
                    Log.w(TAG, "Couldn't show presentation!  Display was removed in "
                            + "the meantime.", ex);
                    mPresentation = null;
                }
            }

            if (mPresentation != null || route.supportsControlCategory(
                    MediaControlIntent.CATEGORY_REMOTE_PLAYBACK)) {
                mMediaPlayer.setSurface((SurfaceHolder)null);
                mMediaPlayer.reset();
                mSurfaceView.setVisibility(View.GONE);
                mLayout.setVisibility(View.GONE);
            } else {
                mLayout.setVisibility(View.VISIBLE);
                mSurfaceView.setVisibility(View.VISIBLE);
            }
        }

        // Listens for when presentations are dismissed.
        private final DialogInterface.OnDismissListener mOnDismissListener =
                new DialogInterface.OnDismissListener() {
            @Override
            public void onDismiss(DialogInterface dialog) {
                if (dialog == mPresentation) {
                    Log.i(TAG, "Presentation was dismissed.");
                    mPresentation = null;
                    updatePresentation();
                }
            }
        };

        private final class DemoPresentation extends Presentation {
            private SurfaceView mPresentationSurfaceView;

            public DemoPresentation(Context context, Display display) {
                super(context, display);
            }

            @Override
            protected void onCreate(Bundle savedInstanceState) {
                // Be sure to call the super class.
                super.onCreate(savedInstanceState);

                // Get the resources for the context of the presentation.
                // Notice that we are getting the resources from the context
                // of the presentation.
                Resources r = getContext().getResources();

                // Inflate the layout.
                setContentView(R.layout.sample_media_router_presentation);

                // Set up the surface view.
                mPresentationSurfaceView = (SurfaceView)findViewById(R.id.surface_view);
                SurfaceHolder holder = mPresentationSurfaceView.getHolder();
                holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
                holder.addCallback(LocalPlayer.this);
            }

            public void updateSize(int width, int height) {
                int surfaceHeight = getWindow().getDecorView().getHeight();
                int surfaceWidth = getWindow().getDecorView().getWidth();
                ViewGroup.LayoutParams lp = mPresentationSurfaceView.getLayoutParams();
                if (surfaceWidth * height < surfaceHeight * width) {
                    lp.width = surfaceWidth;
                    lp.height = surfaceWidth * height / width;
                } else {
                    lp.width = surfaceHeight * width / height;
                    lp.height = surfaceHeight;
                }
                Log.d(TAG, "video rect is " + lp.width + "x" + lp.height);
                mPresentationSurfaceView.setLayoutParams(lp);
            }
        }
    }

    private class RemotePlayer implements Player, MediaSessionManager.Callback {
        private MediaQueueItem mQueueItem;
        private MediaQueueItem mPlaylistItem;
        private String mSessionId;
        private String mItemId;
        private long mPosition;

        public void reset() {
            mQueueItem = null;
            mPlaylistItem = null;
            mSessionId = null;
            mItemId = null;
            mPosition = 0;
        }

        // MediaSessionManager.Callback
        @Override
        public void onStart() {
            resume();
        }

        @Override
        public void onPause() {
            pause();
        }

        @Override
        public void onStop() {
            stop();
        }

        @Override
        public void onSeek(long pos) {
            // If we're currently performing a Play/Enqueue, do not seek
            // until we get the result back (or we may not have valid session
            // and item ids); otherwise do the seek now
            if (mSessionId != null) {
                seek(mSessionId, mItemId, pos);
            }
            // Set current position to seek-to position, actual position will
            // be updated when next getStatus is completed.
            mPosition = pos;
        }

        @Override
        public void onGetStatus(MediaQueueItem item) {
            if (mQueueItem != null) {
                mPlaylistItem = item;
                getStatus(mQueueItem, false);
            }
        }

        @Override
        public void onNewItem(Uri uri) {
            mPosition = 0;
            play(uri, false, 0);
        }

        // Player API
        @Override
        public void enqueue(final Uri uri, long pos) {
            play(uri, true, pos);
        }

        @Override
        public void remove(final MediaQueueItem item) {
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Intent intent = makeRemoveIntent(item);
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        MediaItemStatus status = MediaItemStatus.fromBundle(
                                data.getBundle(MediaControlIntent.EXTRA_ITEM_STATUS));
                        Log.d(TAG, "Remove request succeeded: status=" + status.toString());
                        updateUi();
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Remove request failed: error=" + error + ", data=" + data);
                    }
                };

                Log.d(TAG, "Sending remove request: intent=" + intent);
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Remove request not supported!");
            }
        }

        @Override
        public void seek(String sid, String iid, long pos) {
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Intent intent = makeSeekIntent(sid, iid, pos);
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        MediaItemStatus status = MediaItemStatus.fromBundle(
                                data.getBundle(MediaControlIntent.EXTRA_ITEM_STATUS));
                        Log.d(TAG, "Seek request succeeded: status=" + status.toString());
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Seek request failed: error=" + error + ", data=" + data);
                    }
                };

                Log.d(TAG, "Sending seek request: intent=" + intent);
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Seek request not supported!");
            }
        }

        @Override
        public void getStatus(final MediaQueueItem item, final boolean update) {
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Intent intent = makeGetStatusIntent(item);
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        if (data != null) {
                            String sid = data.getString(MediaControlIntent.EXTRA_SESSION_ID);
                            String iid = data.getString(MediaControlIntent.EXTRA_ITEM_ID);
                            MediaItemStatus status = MediaItemStatus.fromBundle(
                                    data.getBundle(MediaControlIntent.EXTRA_ITEM_STATUS));
                            Log.d(TAG, "GetStatus request succeeded: status=" + status.toString());
                            //showToast("GetStatus request succeeded " + item.mName);
                            if (isRemoteQueue()) {
                                int state = status.getPlaybackState();
                                if (state == MediaItemStatus.PLAYBACK_STATE_PLAYING
                                        || state == MediaItemStatus.PLAYBACK_STATE_PAUSED
                                        || state == MediaItemStatus.PLAYBACK_STATE_PENDING) {
                                    item.setState(state);
                                    item.setContentPosition(status.getContentPosition());
                                    item.setContentDuration(status.getContentDuration());
                                    mLastStatusTime = status.getTimestamp();
                                    mPlayListItems.add(item);
                                    mPlayListView.invalidate();
                                    // update buttons as the queue count might have changed
                                    if (update) {
                                        clearContent();
                                        updateButtons();
                                    }
                                }
                            } else {
                                if (mPlaylistItem != null) {
                                    mPlaylistItem.setContentPosition(status.getContentPosition());
                                    mPlaylistItem.setContentDuration(status.getContentDuration());
                                    mPlaylistItem = null;
                                    updateButtons();
                                }
                            }
                        }
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "GetStatus request failed: error=" + error + ", data=" + data);
                        //showToast("Unable to get status ");
                        if (isRemoteQueue()) {
                            if (update) {
                                clearContent();
                                updateButtons();
                            }
                        }
                    }
                };

                Log.d(TAG, "Sending GetStatus request: intent=" + intent);
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "GetStatus request not supported!");
            }
        }

        @Override
        public void pause() {
            Intent intent = makePauseIntent();
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        Log.d(TAG, "Pause request succeeded");
                        if (isRemoteQueue()) {
                            mPaused = true;
                            updateUi();
                        }
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Pause request failed: error=" + error);
                    }
                };

                Log.d(TAG, "Sending pause request");
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Pause request not supported!");
            }
        }

        @Override
        public void resume() {
            Intent intent = makeResumeIntent();
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        Log.d(TAG, "Resume request succeeded");
                        if (isRemoteQueue()) {
                            mPaused = false;
                            updateUi();
                        }
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Resume request failed: error=" + error);
                    }
                };

                Log.d(TAG, "Sending resume request");
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Resume request not supported!");
            }
        }

        @Override
        public void stop() {
            Intent intent = makeStopIntent();
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        Log.d(TAG, "Stop request succeeded");
                        if (isRemoteQueue()) {
                            // Reset mSessionId, so that next Play/Enqueue
                            // starts a new session
                            mQueueItem = null;
                            mSessionId = null;
                            mPaused = false;
                            updateUi();
                        }
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Stop request failed: error=" + error);
                    }
                };

                Log.d(TAG, "Sending stop request");
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Stop request not supported!");
            }
        }

        @Override
        public void showStatistics() {
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Intent intent = makeStatisticsIntent();
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        Log.d(TAG, "Statistics request succeeded: data=" + data);
                        if (data != null) {
                            int playbackCount = data.getInt(
                                    SampleMediaRouteProvider.DATA_PLAYBACK_COUNT, -1);
                            mStatsInfo = "Total playback count: " + playbackCount;
                        } else {
                            showToast("Statistics query did not return any data");
                        }
                        updateRouteDescription();
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, "Statistics request failed: error=" + error + ", data=" + data);
                        showToast("Unable to query statistics, error: " + error);
                        updateRouteDescription();
                    }
                };

                Log.d(TAG, "Sent statistics request: intent=" + intent);
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, "Statistics request not supported!");
            }

        }

        @Override
        public void onFinish(boolean error) {
            updateUi();
        }

        @Override
        public void updateSize(int width, int height) {
            // nothing to do
        }

        private void play(final Uri uri, boolean enqueue, final long pos) {
            // save the initial seek position
            mPosition = pos;
            MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute();
            Intent intent = makePlayIntent(uri, enqueue);
            final String request = enqueue ? "Enqueue" : "Play";
            if (route.supportsControlRequest(intent)) {
                MediaRouter.ControlRequestCallback callback =
                        new MediaRouter.ControlRequestCallback() {
                    @Override
                    public void onResult(Bundle data) {
                        if (data != null) {
                            String sid = data.getString(MediaControlIntent.EXTRA_SESSION_ID);
                            String iid = data.getString(MediaControlIntent.EXTRA_ITEM_ID);
                            MediaItemStatus status = MediaItemStatus.fromBundle(
                                    data.getBundle(MediaControlIntent.EXTRA_ITEM_STATUS));
                            Log.d(TAG, request + " request succeeded: data=" + data +
                                    ", sid=" + sid + ", iid=" + iid);

                            // perform delayed initial seek
                            if (mSessionId == null && mPosition > 0) {
                                seek(sid, iid, mPosition);
                            }

                            mSessionId = sid;
                            mItemId = iid;
                            mQueueItem = new MediaQueueItem(sid, iid, null, null);

                            if (isRemoteQueue()) {
                                MediaQueueItem playlistItem =
                                        new MediaQueueItem(sid, iid, uri, null);
                                playlistItem.setState(status.getPlaybackState());
                                mPlayListItems.add(playlistItem);
                                updateUi();
                                enqueuePlaylist();
                            }
                        }
                    }

                    @Override
                    public void onError(String error, Bundle data) {
                        Log.d(TAG, request + " request failed: error=" + error + ", data=" + data);
                        showToast("Unable to " + request + uri + ", error: " + error);
                    }
                };

                Log.d(TAG, "Sending " + request + " request: intent=" + intent);
                route.sendControlRequest(intent, callback);
            } else {
                Log.d(TAG, request + " request not supported!");
            }
        }

        private Intent makePlayIntent(Uri uri, boolean enqueue) {
            Intent intent = new Intent(
                    enqueue ? MediaControlIntent.ACTION_ENQUEUE
                            : MediaControlIntent.ACTION_PLAY);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            intent.setDataAndType(uri, "video/mp4");

            // Provide a valid session id, or none (which starts a new session)
            if (mSessionId != null) {
                intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, mSessionId);
            }

            // PendingIntent for receiving status update from MRP
            Intent statusIntent = new Intent(SampleMediaRouterActivity.ACTION_STATUS_CHANGE);
            intent.putExtra(MediaControlIntent.EXTRA_ITEM_STATUS_UPDATE_RECEIVER,
                    PendingIntent.getBroadcast(SampleMediaRouterActivity.this,
                            0, statusIntent, 0));

            return intent;
        }

        private Intent makeRemoveIntent(MediaQueueItem item) {
            Intent intent = new Intent(MediaControlIntent.ACTION_REMOVE);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, item.getSessionId());
            intent.putExtra(MediaControlIntent.EXTRA_ITEM_ID, item.getItemId());
            return intent;
        }

        private Intent makeSeekIntent(String sid, String iid, long pos) {
            Intent intent = new Intent(MediaControlIntent.ACTION_SEEK);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, sid);
            intent.putExtra(MediaControlIntent.EXTRA_ITEM_ID, iid);
            intent.putExtra(MediaControlIntent.EXTRA_ITEM_CONTENT_POSITION, pos);
            return intent;
        }

        private Intent makePauseIntent() {
            Intent intent = new Intent(MediaControlIntent.ACTION_PAUSE);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            if (mSessionId != null) {
                intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, mSessionId);
            }
            return intent;
        }

        private Intent makeResumeIntent() {
            Intent intent = new Intent(MediaControlIntent.ACTION_RESUME);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            if (mSessionId != null) {
                intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, mSessionId);
            }
            return intent;
        }

        private Intent makeStopIntent() {
            Intent intent = new Intent(MediaControlIntent.ACTION_STOP);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            if (mSessionId != null) {
                intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, mSessionId);
            }
            return intent;
        }

        private Intent makeGetStatusIntent(MediaQueueItem item) {
            Intent intent = new Intent(MediaControlIntent.ACTION_GET_STATUS);
            intent.addCategory(MediaControlIntent.CATEGORY_REMOTE_PLAYBACK);
            intent.putExtra(MediaControlIntent.EXTRA_SESSION_ID, item.getSessionId());
            intent.putExtra(MediaControlIntent.EXTRA_ITEM_ID, item.getItemId());
            return intent;
         }

        private Intent makeStatisticsIntent() {
            Intent intent = new Intent(SampleMediaRouteProvider.ACTION_GET_STATISTICS);
            intent.addCategory(SampleMediaRouteProvider.CATEGORY_SAMPLE_ROUTE);
            return intent;
        }
    }

    public static final class DiscoveryFragment extends MediaRouteDiscoveryFragment {
        private static final String TAG = "DiscoveryFragment";
        private Callback mCallback;

        public DiscoveryFragment() {
            mCallback = null;
        }

        public DiscoveryFragment(Callback cb) {
            mCallback = cb;
        }

        public void setCallback(Callback cb) {
            mCallback = cb;
        }

        @Override
        public Callback onCreateCallback() {
            return mCallback;
        }

        @Override
        public int onPrepareCallbackFlags() {
            // Add the CALLBACK_FLAG_UNFILTERED_EVENTS flag to ensure that we will
            // observe and log all route events including those that are for routes
            // that do not match our selector.  This is only for demonstration purposes
            // and should not be needed by most applications.
            return super.onPrepareCallbackFlags()
                    | MediaRouter.CALLBACK_FLAG_UNFILTERED_EVENTS;
        }
    }

    private static final class MediaItem {
        public final String mName;
        public final Uri mUri;

        public MediaItem(String name, Uri uri) {
            mName = name;
            mUri = uri;
        }

        @Override
        public String toString() {
            return mName;
        }
    }

    private final class LibraryAdapter extends ArrayAdapter<MediaItem> {
        public LibraryAdapter() {
            super(SampleMediaRouterActivity.this, R.layout.media_item);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final View v;
            if (convertView == null) {
                v = getLayoutInflater().inflate(R.layout.media_item, null);
            } else {
                v = convertView;
            }

            final MediaItem item = getItem(position);

            TextView tv = (TextView)v.findViewById(R.id.item_text);
            tv.setText(item.mName);

            ImageButton b = (ImageButton)v.findViewById(R.id.item_action);
            b.setImageResource(R.drawable.ic_menu_add);
            b.setTag(item);
            b.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (item != null) {
                        mPlayer.enqueue(item.mUri, 0);
                    }
                }
            });

            return v;
        }
    }

    private final class PlaylistAdapter extends ArrayAdapter<MediaQueueItem> {
        public PlaylistAdapter() {
            super(SampleMediaRouterActivity.this, R.layout.media_item);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final View v;
            if (convertView == null) {
                v = getLayoutInflater().inflate(R.layout.media_item, null);
            } else {
                v = convertView;
            }

            final MediaQueueItem item = getItem(position);

            TextView tv = (TextView)v.findViewById(R.id.item_text);
            tv.setText(item.toString());

            ImageButton b = (ImageButton)v.findViewById(R.id.item_action);
            b.setImageResource(R.drawable.ic_menu_delete);
            b.setTag(item);
            b.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (item != null) {
                        mPlayer.remove(item);
                    }
                }
            });

            return v;
        }
    }

    /**
     * Trivial subclass of this activity used to provide another copy of the
     * same activity using a light theme instead of the dark theme.
     */
    public static class Light extends SampleMediaRouterActivity {
    }

    /**
     * Trivial subclass of this activity used to provide another copy of the
     * same activity using a light theme with dark action bar instead of the dark theme.
     */
    public static class LightWithDarkActionBar extends SampleMediaRouterActivity {
    }
}