Java MediaStatus.PLAYER_STATE_PLAYING属性代码示例

public int getPlaybackStatus() {
    if(mIsPreparing) {
        return ArchosMediaStatus.PLAYER_STATE_PREPARING;
    }
    if(mIsSwitching) {
        return ArchosMediaStatus.PLAYER_STATE_SWITCHING;
    }
    if(Player.sPlayer !=null){
        if(Player.sPlayer.isBusy()){
            return MediaStatus.PLAYER_STATE_PLAYING;
        }
        if (Player.sPlayer.isPlaying()){
            return MediaStatus.PLAYER_STATE_PLAYING;
        }
        if(!Player.sPlayer.isPlaying()&&Player.sPlayer.isInPlaybackState()){
            return MediaStatus.PLAYER_STATE_PAUSED;
        }
    }else if (mCastManager.isConnected()){
        return mCastManager.getPlaybackStatus();
    }
    return MediaStatus.PLAYER_STATE_IDLE;
}
 

@Override
public void onStopTrackingTouch(SeekBar seekBar) {
    try {
        if (mPlaybackState == MediaStatus.PLAYER_STATE_PLAYING) {
            mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            mCastController.setPlaybackStatus(mPlaybackState);
            mCastManager.play(seekBar.getProgress());
        } else if (mPlaybackState == MediaStatus.PLAYER_STATE_PAUSED) {
            mCastManager.seek(seekBar.getProgress());
        }
        restartTrickplayTimer();
    } catch (Exception e) {
        LOGE(TAG, "Failed to complete seek", e);
        mCastController.closeActivity();
    }
}
 

/**
 * A helper method to determine if, given a player state and an idle reason (if the state is
 * idle) will warrant having a UI for remote presentation of the remote content.
 *
 * @throws TransientNetworkDisconnectionException
 * @throws NoConnectionException
 */
public boolean shouldRemoteUiBeVisible(int state, int idleReason)
        throws TransientNetworkDisconnectionException, NoConnectionException {
    switch (state) {
        case MediaStatus.PLAYER_STATE_PLAYING:
        case MediaStatus.PLAYER_STATE_PAUSED:
        case MediaStatus.PLAYER_STATE_BUFFERING:
            return true;
        case MediaStatus.PLAYER_STATE_IDLE:
            if (isRemoteStreamLive() && (idleReason == MediaStatus.IDLE_REASON_CANCELED)) {
                // we have a live stream and we have "stopped/paused" it
                return true;
            } else {
                // if we have not reached the end of queue, return true otherwise return false
                return mMediaStatus != null && (mMediaStatus.getLoadingItemId()
                        != MediaQueueItem.INVALID_ITEM_ID);
            }
        default:
    }
    return false;
}
 

private boolean changeVolume(double volumeIncrement, boolean isKeyDown) {
    if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
            && getPlaybackStatus() == MediaStatus.PLAYER_STATE_PLAYING
            && isFeatureEnabled(CastConfiguration.FEATURE_LOCKSCREEN)) {
        return false;
    }

    if (isKeyDown) {
        try {
            adjustVolume(volumeIncrement);
        } catch (CastException | TransientNetworkDisconnectionException |
                NoConnectionException e) {
            LOGE(TAG, "Failed to change volume", e);
        }
    }
    return true;
}
 

private void updatePlayPauseButtonImageResource(ImageButton button) {
    CastSession castSession = CastContext.getSharedInstance(mAppContext)
            .getSessionManager().getCurrentCastSession();
    RemoteMediaClient remoteMediaClient =
            (castSession == null) ? null : castSession.getRemoteMediaClient();
    if (remoteMediaClient == null) {
        button.setVisibility(View.GONE);
        return;
    }
    int status = remoteMediaClient.getPlayerState();
    switch (status) {
        case MediaStatus.PLAYER_STATE_PLAYING:
            button.setImageResource(PAUSE_RESOURCE);
            break;
        case MediaStatus.PLAYER_STATE_PAUSED:
            button.setImageResource(PLAY_RESOURCE);
            break;
        default:
            button.setVisibility(View.GONE);
    }
}
 

/**
 * 再生状態を文字列に変換する.
 * 
 * @param   playState   再生状態
 * @return  再生状態の文字列を返す
 */
public String getPlayStatus(final int playState) {
    switch (playState) {
    case MediaStatus.PLAYER_STATE_BUFFERING:
        return MESSAGE_BUFFERING;
    case MediaStatus.PLAYER_STATE_IDLE:
        return MESSAGE_STOP;
    case MediaStatus.PLAYER_STATE_PAUSED:
        return MESSAGE_PAUSED;
    case MediaStatus.PLAYER_STATE_PLAYING:
        return MESSAGE_PALYING;
    case MediaStatus.PLAYER_STATE_UNKNOWN:
    default:
        return MESSAGE_UNKNOWN;
    }
}
 

/**
 * A helper method to determine if, given a player state and an idle reason (if the state is
 * idle) will warrant having a UI for remote presentation of the remote content.
 *
 * @param state
 * @param idleReason
 * @return
 * @throws TransientNetworkDisconnectionException
 * @throws NoConnectionException
 */
public boolean shouldRemoteUiBeVisible(int state, int idleReason)
        throws TransientNetworkDisconnectionException,
        NoConnectionException {
    switch (state) {
        case MediaStatus.PLAYER_STATE_PLAYING:
        case MediaStatus.PLAYER_STATE_PAUSED:
        case MediaStatus.PLAYER_STATE_BUFFERING:
            return true;
        case MediaStatus.PLAYER_STATE_IDLE:
            if (!isRemoteStreamLive()) {
                return false;
            }
            return idleReason == MediaStatus.IDLE_REASON_CANCELED;
        default:
            break;
    }
    return false;
}
 

/**
 * A helper method to determine if, given a player state and an idle reason (if the state is
 * idle) will warrant having a UI for remote presentation of the remote content.
 *
 * @param state
 * @param idleReason
 * @return
 * @throws TransientNetworkDisconnectionException
 * @throws NoConnectionException
 */
public boolean shouldRemoteUiBeVisible(int state, int idleReason) throws TransientNetworkDisconnectionException, NoConnectionException {
  switch (state) {
    case MediaStatus.PLAYER_STATE_PLAYING:
    case MediaStatus.PLAYER_STATE_PAUSED:
    case MediaStatus.PLAYER_STATE_BUFFERING:
      return true;
    case MediaStatus.PLAYER_STATE_IDLE:
      if (!isRemoteStreamLive()) {
        return false;
      }
      return idleReason == MediaStatus.IDLE_REASON_CANCELED;
    default:
      break;
  }
  return false;
}
 

public void onReady(MediaInfo mediaInfo, boolean shouldStartPlayback, int startPoint) {
  mSelectedMedia = mediaInfo;
  try {
    mCastController.setStreamType(mSelectedMedia.getStreamType());
    if (shouldStartPlayback) {
      // need to start remote playback
      mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
      mCastController.setPlaybackStatus(mPlaybackState);
      mCastManager.loadMedia(mSelectedMedia, true, startPoint);
    } else {
      // we don't change the status of remote playback
      if (mCastManager.isRemoteMoviePlaying()) {
        mPlaybackState = MediaStatus.PLAYER_STATE_PLAYING;
      } else {
        mPlaybackState = MediaStatus.PLAYER_STATE_PAUSED;
      }
      mCastController.setPlaybackStatus(mPlaybackState);
    }
  } catch (Exception e) {
    CastUtils.LOGE(TAG, "Failed to get playback and media information", e);
    mCastController.closeActivity();
  }
  updateMetadata();
  restartTrickplayTimer();
}
 

@Override
public void onStopTrackingTouch(SeekBar seekBar) {
  try {
    if (mPlaybackState == MediaStatus.PLAYER_STATE_PLAYING) {
      mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
      mCastController.setPlaybackStatus(mPlaybackState);
      mCastManager.play(seekBar.getProgress());
    } else if (mPlaybackState == MediaStatus.PLAYER_STATE_PAUSED) {
      mCastManager.seek(seekBar.getProgress());
    }
    restartTrickplayTimer();
  } catch (Exception e) {
    CastUtils.LOGE(TAG, "Failed to complete seek", e);
    mCastController.closeActivity();
  }
}
 

private void togglePlayback() throws CastException, TransientNetworkDisconnectionException, NoConnectionException {
  switch (mPlaybackState) {
    case MediaStatus.PLAYER_STATE_PAUSED:
      mCastManager.play();
      mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
      restartTrickplayTimer();
      break;
    case MediaStatus.PLAYER_STATE_PLAYING:
      mCastManager.pause();
      mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
      break;
    case MediaStatus.PLAYER_STATE_IDLE:
      if ((mSelectedMedia.getStreamType() == MediaInfo.STREAM_TYPE_LIVE) && (mCastManager.getIdleReason() == MediaStatus.IDLE_REASON_CANCELED)) {
        mCastManager.play();
      } else {
        mCastManager.loadMedia(mSelectedMedia, true, 0);
      }
      mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
      restartTrickplayTimer();
      break;
    default:
      break;
  }
  mCastController.setPlaybackStatus(mPlaybackState);
}
 

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (mCastManager.isConnected()) {
        if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
            onVolumeChange((double) mVolumeIncrement);
        } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
            onVolumeChange(-(double) mVolumeIncrement);
        } else {
            // we don't want to consume non-volume key events
            return super.onKeyDown(keyCode, event);
        }
        if (mCastManager.getPlaybackStatus() == MediaStatus.PLAYER_STATE_PLAYING) {
            return super.onKeyDown(keyCode, event);
        } else {
            return true;
        }
    }
    return super.onKeyDown(keyCode, event);
}
 

private void onReady(MediaInfo mediaInfo, boolean shouldStartPlayback, int startPoint,
        JSONObject customData) {
    mSelectedMedia = mediaInfo;
    try {
        mCastController.setStreamType(mSelectedMedia.getStreamType());
        if (shouldStartPlayback) {
            // need to start remote playback
            mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            mCastController.setPlaybackStatus(mPlaybackState);
            mCastManager.loadMedia(mSelectedMedia, true, startPoint, customData);
        } else {
            // we don't change the status of remote playback
            if (mCastManager.isRemoteMoviePlaying()) {
                mPlaybackState = MediaStatus.PLAYER_STATE_PLAYING;
            } else {
                mPlaybackState = MediaStatus.PLAYER_STATE_PAUSED;
            }
            mCastController.setPlaybackStatus(mPlaybackState);
        }
    } catch (Exception e) {
        LOGE(TAG, "Failed to get playback and media information", e);
        mCastController.closeActivity();
    }
    updateMetadata();
    restartTrickplayTimer();
}
 

/**
 * Loads the media on the cast device.
 *
 * @param mediaInfo The media to be loaded
 * @param shouldStartPlayback If {@code true}, playback starts after load automatically
 * @param startPoint The position to start the play back
 * @param customData An optional custom data to be sent along the load api; it can be
 * {@code null}
 */
private void onReady(MediaInfo mediaInfo, boolean shouldStartPlayback, int startPoint,
                     JSONObject customData) {
    mSelectedMedia = mediaInfo;
    updateClosedCaptionState();
    try {
        mCastController.setStreamType(mSelectedMedia.getStreamType());
        if (shouldStartPlayback) {
            // need to start remote playback
            mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            mCastController.setPlaybackStatus(mPlaybackState);
            mCastManager.loadMedia(mSelectedMedia, true, startPoint, customData);
        } else {
            // we don't change the status of remote playback
            if (mCastManager.isRemoteMediaPlaying()) {
                mPlaybackState = MediaStatus.PLAYER_STATE_PLAYING;
            } else {
                mPlaybackState = MediaStatus.PLAYER_STATE_PAUSED;
            }
            mCastController.setPlaybackStatus(mPlaybackState);
        }
    } catch (Exception e) {
        LOGE(TAG, "Failed to get playback and media information", e);
        mCastController.closeActivity();
    }
    MediaQueue mediaQueue = mCastManager.getMediaQueue();
    int size = 0;
    int position = 0;
    if (mediaQueue != null) {
        size = mediaQueue.getCount();
        position = mediaQueue.getCurrentItemPosition();
    }
    mCastController.onQueueItemsUpdated(size, position);
    updateMetadata();
    restartTrickplayTimer();
}
 

private void togglePlayback() throws CastException, TransientNetworkDisconnectionException,
        NoConnectionException {
    switch (mPlaybackState) {
        case MediaStatus.PLAYER_STATE_PAUSED:
            mCastManager.play();
            //mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            restartTrickplayTimer();
            break;
        case MediaStatus.PLAYER_STATE_PLAYING:
            mCastManager.pause();
            //mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            break;
        case MediaStatus.PLAYER_STATE_IDLE:
            if ((mSelectedMedia.getStreamType() == MediaInfo.STREAM_TYPE_LIVE)
                    && (mCastManager.getIdleReason() == MediaStatus.IDLE_REASON_CANCELED)) {
                mCastManager.play();
            } else {
                mCastManager.loadMedia(mSelectedMedia, true, 0);
            }
            //mPlaybackState = MediaStatus.PLAYER_STATE_BUFFERING;
            restartTrickplayTimer();
            break;
        default:
            break;
    }
    mCastController.setPlaybackStatus(mPlaybackState);
}