Java MediaItemStatus.PLAYBACK_STATE_PLAYING属性代码示例

public PlaylistItem seek(String iid, long pos) {
    if (DEBUG) {
        log("seek: iid=" + iid +", pos=" + pos);
    }
    checkPlayerAndSession();
    // seeking on pending items are not yet supported
    checkItemCurrent(iid);

    PlaylistItem item = getCurrentItem();
    if (pos != item.getPosition()) {
        item.setPosition(pos);
        if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
                || item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
            mPlayer.seek(item);
        }
    }
    return item;
}
 

private void updatePlaybackState() {
    PlaylistItem item = getCurrentItem();
    if (item != null) {
        if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PENDING) {
            item.setState(mPaused ? MediaItemStatus.PLAYBACK_STATE_PAUSED
                    : MediaItemStatus.PLAYBACK_STATE_PLAYING);
            if (!mPlayer.isQueuingSupported()) {
                mPlayer.play(item);
            }
        } else if (mPaused && item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING) {
            mPlayer.pause();
            item.setState(MediaItemStatus.PLAYBACK_STATE_PAUSED);
        } else if (!mPaused && item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
            mPlayer.resume();
            item.setState(MediaItemStatus.PLAYBACK_STATE_PLAYING);
        }
        // notify client that item playback status has changed
        if (mCallback != null) {
            mCallback.onItemChanged(item);
        }
    }
    updateStatus();
}
 

private void updateProgress() {
    // 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;
    PlaylistItem item = getCheckedPlaylistItem();
    if (item != null) {
        int state = item.getState();
        long duration = item.getDuration();
        if (duration <= 0) {
            if (state == MediaItemStatus.PLAYBACK_STATE_PLAYING
                    || state == MediaItemStatus.PLAYBACK_STATE_PAUSED) {
                mSessionManager.updateStatus();
            }
        } else {
            long position = item.getPosition();
            long timeDelta = mSessionManager.isPaused() ? 0 :
                    (SystemClock.elapsedRealtime() - item.getTimestamp());
            progress = (int)(100.0 * (position + timeDelta) / duration);
        }
    }
    mSeekBar.setProgress(progress);
}
 

@VisibleForTesting
void setPlayerStateForMediaItemState(int state) {
    PlayerState playerState = PlayerState.STOPPED;
    switch (state) {
        case MediaItemStatus.PLAYBACK_STATE_BUFFERING:
            playerState = PlayerState.LOADING;
            break;
        case MediaItemStatus.PLAYBACK_STATE_CANCELED:
            playerState = PlayerState.FINISHED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_ERROR:
            playerState = PlayerState.ERROR;
            break;
        case MediaItemStatus.PLAYBACK_STATE_FINISHED:
            playerState = PlayerState.FINISHED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_INVALIDATED:
            playerState = PlayerState.INVALIDATED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_PAUSED:
            if (isAtEndOfVideo(getPosition(), getDuration())) {
                playerState = PlayerState.FINISHED;
            } else {
                playerState = PlayerState.PAUSED;
            }
            break;
        case MediaItemStatus.PLAYBACK_STATE_PENDING:
            playerState = PlayerState.PAUSED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_PLAYING:
            playerState = PlayerState.PLAYING;
            break;
        default:
            break;
    }

    mRemotePlayerState = playerState;
}
 

@VisibleForTesting
void setPlayerStateForMediaItemState(int state) {
    PlayerState playerState = PlayerState.STOPPED;
    switch (state) {
        case MediaItemStatus.PLAYBACK_STATE_BUFFERING:
            playerState = PlayerState.LOADING;
            break;
        case MediaItemStatus.PLAYBACK_STATE_CANCELED:
            playerState = PlayerState.FINISHED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_ERROR:
            playerState = PlayerState.ERROR;
            break;
        case MediaItemStatus.PLAYBACK_STATE_FINISHED:
            playerState = PlayerState.FINISHED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_INVALIDATED:
            playerState = PlayerState.INVALIDATED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_PAUSED:
            if (isAtEndOfVideo(getPosition(), getDuration())) {
                playerState = PlayerState.FINISHED;
            } else {
                playerState = PlayerState.PAUSED;
            }
            break;
        case MediaItemStatus.PLAYBACK_STATE_PENDING:
            playerState = PlayerState.PAUSED;
            break;
        case MediaItemStatus.PLAYBACK_STATE_PLAYING:
            playerState = PlayerState.PLAYING;
            break;
        default:
            break;
    }

    mPlaybackState = playerState;
}
 

private PlaylistItem removeItem(String iid, int state) {
    checkPlayerAndSession();
    List<PlaylistItem> queue =
            new ArrayList<PlaylistItem>(mPlaylist.size());
    PlaylistItem found = null;
    for (PlaylistItem item : mPlaylist) {
        if (iid.equals(item.getItemId())) {
            if (mPlayer.isQueuingSupported()) {
                mPlayer.remove(item.getRemoteItemId());
            } else if (item.getState() == MediaItemStatus.PLAYBACK_STATE_PLAYING
                    || item.getState() == MediaItemStatus.PLAYBACK_STATE_PAUSED){
                mPlayer.stop();
            }
            item.setState(state);
            found = item;
            // notify client that item is now removed
            if (mCallback != null) {
                mCallback.onItemChanged(found);
            }
        } else {
            queue.add(item);
        }
    }
    if (found != null) {
        mPlaylist = queue;
        updatePlaybackState();
    } else {
        log("item not found");
    }
    return found;
}
 

/**
 * Starts playback and sets completion listener.
 */
@Override
public void onPrepared(MediaPlayer mp) {
	mPlayer.start();
	mState = MediaItemStatus.PLAYBACK_STATE_PLAYING;
	mPlayer.setOnCompletionListener(this);
}
 

/**
 * Receives information from MediaRouterPlayService about playback status.
 */
public void receivePlaybackStatus(MediaItemStatus status) {
	// Views may not exist if fragment was just created/destroyed.
	if (getView() == null)
		return;

	int currentTime = (int) status.getContentPosition() / 1000;
	int totalTime = (int) status.getContentDuration() / 1000;

	mCurrentTimeView.setText(generateTimeString(currentTime));
	mTotalTimeView.setText(generateTimeString(totalTime));

	mProgressBar.setProgress(currentTime);
	mProgressBar.setMax(totalTime);

	if (status.getPlaybackState() == MediaItemStatus.PLAYBACK_STATE_PLAYING ||
			status.getPlaybackState() == MediaItemStatus.PLAYBACK_STATE_BUFFERING ||
			status.getPlaybackState() == MediaItemStatus.PLAYBACK_STATE_PENDING) {
		changePlayPauseState(true);
	}
	else {
		changePlayPauseState(false);
	}

	if (mListView.getAdapter() == mPlaylistAdapter) {
		enableTrackHighlight();
	}
}
 

private void processMediaStatusBundle(Bundle statusBundle) {
    if (statusBundle == null) return;
    logBundle("processMediaStatusBundle: ", statusBundle);

    String itemId = statusBundle.getString(MediaControlIntent.EXTRA_ITEM_ID);
    if (itemId == null || !itemId.equals(mCurrentItemId)) return;

    // Extract item metadata, if available.
    if (statusBundle.containsKey(MediaControlIntent.EXTRA_ITEM_METADATA)) {
        Bundle metadataBundle =
                (Bundle) statusBundle.getParcelable(MediaControlIntent.EXTRA_ITEM_METADATA);
        updateTitle(metadataBundle.getString(MediaItemMetadata.KEY_TITLE, mPreferredTitle));
    }

    // Extract the item status, if available.
    if (statusBundle.containsKey(MediaControlIntent.EXTRA_ITEM_STATUS)) {
        Bundle itemStatusBundle =
                (Bundle) statusBundle.getParcelable(MediaControlIntent.EXTRA_ITEM_STATUS);
        MediaItemStatus itemStatus = MediaItemStatus.fromBundle(itemStatusBundle);

        logBundle("Received item status: ", itemStatusBundle);

        updateState(itemStatus.getPlaybackState());

        // Update the PositionExtrapolator that the playback state has changed.
        if (itemStatus.getPlaybackState() == MediaItemStatus.PLAYBACK_STATE_PLAYING) {
            mPositionExtrapolator.onResumed();
        } else if (itemStatus.getPlaybackState() == MediaItemStatus.PLAYBACK_STATE_FINISHED) {
            mPositionExtrapolator.onFinished();
        } else {
            mPositionExtrapolator.onPaused();
        }

        if ((getRemotePlayerState() == PlayerState.PAUSED)
                || (getRemotePlayerState() == PlayerState.PLAYING)
                || (getRemotePlayerState() == PlayerState.LOADING)) {
            this.mCurrentItemId = itemId;

            // duration can possibly be -1 if it's unknown, so cap to 0
            long duration = Math.max(itemStatus.getContentDuration(), 0);
            // update the position using the remote player's position
            // duration can possibly be -1 if it's unknown, so cap to 0
            long position = Math.min(Math.max(itemStatus.getContentPosition(), 0), duration);
            // TODO(zqzhang): The GMS core currently uses SystemClock.uptimeMillis() as
            // timestamp, which does not conform to the MediaRouter support library docs. See
            // b/28378525 and
            // http://developer.android.com/reference/android/support/v7/media/MediaItemStatus.html#getTimestamp().
            // Override the timestamp with elapsedRealtime() by assuming the delay between the
            // GMS core produces the MediaItemStatus and the code reaches here is short enough.
            // long timestamp = itemStatus.getTimestamp();
            long timestamp = SystemClock.elapsedRealtime();
            notifyDurationUpdated(duration);
            notifyPositionUpdated(position);
            mPositionExtrapolator.onPositionInfoUpdated(duration, position, timestamp);

            if (mSeeking) {
                mSeeking = false;
                if (getMediaStateListener() != null) getMediaStateListener().onSeekCompleted();
            }
        }
        logExtraHttpInfo(itemStatus.getExtras());
    }
}