Android VideoView类实例讲解

 public class VideoView extends SurfaceView implements MediaPlayerControl { 
 private String TAG = "VideoView"; 
 // settable by the client 
 private Uri   mUri; 
 private int   mDuration; 
 
 // all possible internal states 
 private static final int STATE_ERROR    = -1; 
 private static final int STATE_IDLE    = 0; 
 private static final int STATE_PREPARING   = 1; 
 private static final int STATE_PREPARED   = 2; 
 private static final int STATE_PLAYING   = 3; 
 private static final int STATE_PAUSED    = 4; 
 private static final int STATE_PLAYBACK_COMPLETED = 5; 
 
 // mCurrentState is a VideoView object's current state. 
 // mTargetState is the state that a method caller intends to reach. 
 // For instance, regardless the VideoView object's current state, 
 // calling pause() intends to bring the object to a target state 
 // of STATE_PAUSED. 
 private int mCurrentState = STATE_IDLE; 
 private int mTargetState = STATE_IDLE; 
 
 // All the stuff we need for playing and showing a video 
 private SurfaceHolder mSurfaceHolder = null; 
 private MediaPlayer mMediaPlayer = null; 
 private int   mVideoWidth; 
 private int   mVideoHeight; 
 private int   mSurfaceWidth; 
 private int   mSurfaceHeight; 
 private MediaController mMediaController; 
 private OnCompletionListener mOnCompletionListener; 
 private MediaPlayer.OnPreparedListener mOnPreparedListener; 
 private int   mCurrentBufferPercentage; 
 private OnErrorListener mOnErrorListener; 
 private int   mSeekWhenPrepared; // recording the seek position while preparing 
 private boolean  mCanPause; 
 private boolean  mCanSeekBack; 
 private boolean  mCanSeekForward; 
 
 public VideoView(Context context) { 
  super(context); 
  initVideoView(); 
 } 
  
 public VideoView(Context context, AttributeSet attrs) { 
  this(context, attrs, 0); 
  initVideoView(); 
 } 
  
 public VideoView(Context context, AttributeSet attrs, int defStyle) { 
  super(context, attrs, defStyle); 
  initVideoView(); 
 } 
 
 @Override 
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
  //Log.i("@@@@", "onMeasure"); 
  int width = getDefaultSize(mVideoWidth, widthMeasureSpec); 
  int height = getDefaultSize(mVideoHeight, heightMeasureSpec); 
  if (mVideoWidth > 0 && mVideoHeight > 0) { 
   if ( mVideoWidth * height > width * mVideoHeight ) { 
    //Log.i("@@@", "image too tall, correcting"); 
    height = width * mVideoHeight / mVideoWidth; 
   } else if ( mVideoWidth * height < width * mVideoHeight ) { 
    //Log.i("@@@", "image too wide, correcting"); 
    width = height * mVideoWidth / mVideoHeight; 
   } else { 
    //Log.i("@@@", "aspect ratio is correct: " + 
      //width+"/"+height+"="+ 
      //mVideoWidth+"/"+mVideoHeight); 
   } 
  } 
  //Log.i("@@@@@@@@@@", "setting size: " + width + 'x' + height); 
  setMeasuredDimension(width, height); 
 } 
  
 public int resolveAdjustedSize(int desiredSize, int measureSpec) { 
  int result = desiredSize; 
  int specMode = MeasureSpec.getMode(measureSpec); 
  int specSize = MeasureSpec.getSize(measureSpec); 
 
  switch (specMode) { 
   case MeasureSpec.UNSPECIFIED: 
        result = desiredSize; 
    break; 
 
   case MeasureSpec.AT_MOST: 
    /* Parent says we can be as big as we want, up to specSize. 
     * Don't be larger than specSize, and don't be larger than 
     * the max size imposed on ourselves. 
     */ 
    result = Math.min(desiredSize, specSize); 
    break; 
     
   case MeasureSpec.EXACTLY: 
    // No choice. Do what we are told. 
    result = specSize; 
    break; 
  } 
  return result; 
} 
  
 private void initVideoView() { 
  mVideoWidth = 0; 
  mVideoHeight = 0; 
  getHolder().addCallback(mSHCallback); 
  getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); 
  setFocusable(true); 
  setFocusableInTouchMode(true); 
  requestFocus(); 
  mCurrentState = STATE_IDLE; 
  mTargetState = STATE_IDLE; 
 } 
 
 public void setVideoPath(String path) { 
  setVideoURI(Uri.parse(path)); 
 } 
 
 public void setVideoURI(Uri uri) { 
  mUri = uri; 
  mSeekWhenPrepared = 0; 
  openVideo(); 
  requestLayout(); 
  invalidate(); 
 } 
  
 public void stopPlayback() { 
  if (mMediaPlayer != null) { 
   mMediaPlayer.stop(); 
   mMediaPlayer.release(); 
   mMediaPlayer = null; 
   mCurrentState = STATE_IDLE; 
   mTargetState = STATE_IDLE; 
  } 
 } 
 
 private void openVideo() { 
  if (mUri == null || mSurfaceHolder == null) { 
   // not ready for playback just yet, will try again later 
   return; 
  } 
  // Tell the music playback service to pause 
  // TODO: these constants need to be published somewhere in the framework. 
  Intent i = new Intent("com.android.music.musicservicecommand"); 
  i.putExtra("command", "pause"); 
  mContext.sendBroadcast(i); 
 
  // we shouldn't clear the target state, because somebody might have 
  // called start() previously 
  release(false); 
  try { 
   mMediaPlayer = new MediaPlayer(); 
   mMediaPlayer.setOnPreparedListener(mPreparedListener); 
   mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener); 
   mDuration = -1; 
   mMediaPlayer.setOnCompletionListener(mCompletionListener); 
   mMediaPlayer.setOnErrorListener(mErrorListener); 
   mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener); 
   mCurrentBufferPercentage = 0; 
   mMediaPlayer.setDataSource(mContext, mUri); 
   mMediaPlayer.setDisplay(mSurfaceHolder); 
   mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); 
   mMediaPlayer.setScreenOnWhilePlaying(true); 
   mMediaPlayer.prepareAsync(); 
   // we don't set the target state here either, but preserve the 
   // target state that was there before. 
   mCurrentState = STATE_PREPARING; 
   attachMediaController(); 
  } catch (IOException ex) { 
   Log.w(TAG, "Unable to open content: " + mUri, ex); 
   mCurrentState = STATE_ERROR; 
   mTargetState = STATE_ERROR; 
   mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0); 
   return; 
  } catch (IllegalArgumentException ex) { 
   Log.w(TAG, "Unable to open content: " + mUri, ex); 
   mCurrentState = STATE_ERROR; 
   mTargetState = STATE_ERROR; 
   mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0); 
   return; 
  } 
 } 
  
 public void setMediaController(MediaController controller) { 
  if (mMediaController != null) { 
   mMediaController.hide(); 
  } 
  mMediaController = controller; 
  attachMediaController(); 
 } 
 
 private void attachMediaController() { 
  if (mMediaPlayer != null && mMediaController != null) { 
   mMediaController.setMediaPlayer(this); 
   View anchorView = this.getParent() instanceof View ? 
     (View)this.getParent() : this; 
   mMediaController.setAnchorView(anchorView); 
   mMediaController.setEnabled(isInPlaybackState()); 
  } 
 } 
  
 MediaPlayer.OnVideoSizeChangedListener mSizeChangedListener = 
  new MediaPlayer.OnVideoSizeChangedListener() { 
   public void onVideoSizeChanged(MediaPlayer mp, int width, int height) { 
    mVideoWidth = mp.getVideoWidth(); 
    mVideoHeight = mp.getVideoHeight(); 
    if (mVideoWidth != 0 && mVideoHeight != 0) { 
     getHolder().setFixedSize(mVideoWidth, mVideoHeight); 
    } 
   } 
 }; 
  
 MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() { 
  public void onPrepared(MediaPlayer mp) { 
   mCurrentState = STATE_PREPARED; 
 
   // Get the capabilities of the player for this stream 
   Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL, 
          MediaPlayer.BYPASS_METADATA_FILTER); 
 
   if (data != null) { 
    mCanPause = !data.has(Metadata.PAUSE_AVAILABLE) 
      || data.getBoolean(Metadata.PAUSE_AVAILABLE); 
    mCanSeekBack = !data.has(Metadata.SEEK_BACKWARD_AVAILABLE) 
      || data.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE); 
    mCanSeekForward = !data.has(Metadata.SEEK_FORWARD_AVAILABLE) 
      || data.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE); 
   } else { 
    mCanPause = mCanSeekForward = mCanSeekForward = true; 
   } 
 
   if (mOnPreparedListener != null) { 
    mOnPreparedListener.onPrepared(mMediaPlayer); 
   } 
   if (mMediaController != null) { 
    mMediaController.setEnabled(true); 
   } 
   mVideoWidth = mp.getVideoWidth(); 
   mVideoHeight = mp.getVideoHeight(); 
 
   int seekToPosition = mSeekWhenPrepared; // mSeekWhenPrepared may be changed after seekTo() call 
   if (seekToPosition != 0) { 
    seekTo(seekToPosition); 
   } 
   if (mVideoWidth != 0 && mVideoHeight != 0) { 
    //Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight); 
    getHolder().setFixedSize(mVideoWidth, mVideoHeight); 
    if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) { 
     // We didn't actually change the size (it was already at the size 
     // we need), so we won't get a "surface changed" callback, so 
     // start the video here instead of in the callback. 
     if (mTargetState == STATE_PLAYING) { 
      start(); 
      if (mMediaController != null) { 
       mMediaController.show(); 
      } 
     } else if (!isPlaying() && 
        (seekToPosition != 0 || getCurrentPosition() > 0)) { 
      if (mMediaController != null) { 
       // Show the media controls when we're paused into a video and make 'em stick. 
       mMediaController.show(0); 
      } 
     } 
    } 
   } else { 
    // We don't know the video size yet, but should start anyway. 
    // The video size might be reported to us later. 
    if (mTargetState == STATE_PLAYING) { 
     start(); 
    } 
   } 
  } 
 }; 
 
 private MediaPlayer.OnCompletionListener mCompletionListener = 
  new MediaPlayer.OnCompletionListener() { 
  public void onCompletion(MediaPlayer mp) { 
   mCurrentState = STATE_PLAYBACK_COMPLETED; 
   mTargetState = STATE_PLAYBACK_COMPLETED; 
   if (mMediaController != null) { 
    mMediaController.hide(); 
   } 
   if (mOnCompletionListener != null) { 
    mOnCompletionListener.onCompletion(mMediaPlayer); 
   } 
  } 
 }; 
 
 private MediaPlayer.OnErrorListener mErrorListener = 
  new MediaPlayer.OnErrorListener() { 
  public boolean onError(MediaPlayer mp, int framework_err, int impl_err) { 
   Log.d(TAG, "Error: " + framework_err + "," + impl_err); 
   mCurrentState = STATE_ERROR; 
   mTargetState = STATE_ERROR; 
   if (mMediaController != null) { 
    mMediaController.hide(); 
   } 
 
   /* If an error handler has been supplied, use it and finish. */ 
   if (mOnErrorListener != null) { 
    if (mOnErrorListener.onError(mMediaPlayer, framework_err, impl_err)) { 
     return true; 
    } 
   } 
 
   /* Otherwise, pop up an error dialog so the user knows that 
    * something bad has happened. Only try and pop up the dialog 
    * if we're attached to a window. When we're going away and no 
    * longer have a window, don't bother showing the user an error. 
    */ 
   if (getWindowToken() != null) { 
    Resources r = mContext.getResources(); 
    int messageId; 
 
    if (framework_err == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) { 
     messageId = com.android.internal.R.string.VideoView_error_text_invalid_progressive_playback; 
    } else { 
     messageId = com.android.internal.R.string.VideoView_error_text_unknown; 
    } 
 
    new AlertDialog.Builder(mContext) 
      .setTitle(com.android.internal.R.string.VideoView_error_title) 
      .setMessage(messageId) 
      .setPositiveButton(com.android.internal.R.string.VideoView_error_button, 
        new DialogInterface.OnClickListener() { 
         public void onClick(DialogInterface dialog, int whichButton) { 
          /* If we get here, there is no onError listener, so 
           * at least inform them that the video is over. 
           */ 
          if (mOnCompletionListener != null) { 
           mOnCompletionListener.onCompletion(mMediaPlayer); 
          } 
         } 
        }) 
      .setCancelable(false) 
      .show(); 
   } 
   return true; 
  } 
 }; 
 
 private MediaPlayer.OnBufferingUpdateListener mBufferingUpdateListener = 
  new MediaPlayer.OnBufferingUpdateListener() { 
  public void onBufferingUpdate(MediaPlayer mp, int percent) { 
   mCurrentBufferPercentage = percent; 
  } 
 }; 
 
 /** 
  * Register a callback to be invoked when the media file 
  * is loaded and ready to go. 
  * 
  * @param l The callback that will be run 
  */ 
 public void setOnPreparedListener(MediaPlayer.OnPreparedListener l) 
 { 
  mOnPreparedListener = l; 
 } 
 
 /** 
  * Register a callback to be invoked when the end of a media file 
  * has been reached during playback. 
  * 
  * @param l The callback that will be run 
  */ 
 public void setOnCompletionListener(OnCompletionListener l) 
 { 
  mOnCompletionListener = l; 
 } 
 
 /** 
  * Register a callback to be invoked when an error occurs 
  * during playback or setup. If no listener is specified, 
  * or if the listener returned false, VideoView will inform 
  * the user of any errors. 
  * 
  * @param l The callback that will be run 
  */ 
 public void setOnErrorListener(OnErrorListener l) 
 { 
  mOnErrorListener = l; 
 } 
 
 SurfaceHolder.Callback mSHCallback = new SurfaceHolder.Callback() 
 { 
  public void surfaceChanged(SurfaceHolder holder, int format, 
         int w, int h) 
  { 
   mSurfaceWidth = w; 
   mSurfaceHeight = h; 
   boolean isValidState = (mTargetState == STATE_PLAYING); 
   boolean hasValidSize = (mVideoWidth == w && mVideoHeight == h); 
   if (mMediaPlayer != null && isValidState && hasValidSize) { 
    if (mSeekWhenPrepared != 0) { 
     seekTo(mSeekWhenPrepared); 
    } 
    start(); 
    if (mMediaController != null) { 
     mMediaController.show(); 
    } 
   } 
  } 
 
  public void surfaceCreated(SurfaceHolder holder) 
  { 
   mSurfaceHolder = holder; 
   openVideo(); 
  } 
 
  public void surfaceDestroyed(SurfaceHolder holder) 
  { 
   // after we return from this we can't use the surface any more 
   mSurfaceHolder = null; 
   if (mMediaController != null) mMediaController.hide(); 
   release(true); 
  } 
 }; 
 
  private void release(boolean cleartargetstate) { 
  if (mMediaPlayer != null) { 
   mMediaPlayer.reset(); 
   mMediaPlayer.release(); 
   mMediaPlayer = null; 
   mCurrentState = STATE_IDLE; 
   if (cleartargetstate) { 
    mTargetState = STATE_IDLE; 
   } 
  } 
 } 
 
 @Override 
 public boolean onTouchEvent(MotionEvent ev) { 
  if (isInPlaybackState() && mMediaController != null) { 
   toggleMediaControlsVisiblity(); 
  } 
  return false; 
 } 
  
 @Override 
 public boolean onTrackballEvent(MotionEvent ev) { 
  if (isInPlaybackState() && mMediaController != null) { 
   toggleMediaControlsVisiblity(); 
  } 
  return false; 
 } 
  
 @Override 
 public boolean onKeyDown(int keyCode, KeyEvent event) 
 { 
  boolean isKeyCodeSupported = keyCode != KeyEvent.KEYCODE_BACK && 
          keyCode != KeyEvent.KEYCODE_VOLUME_UP && 
          keyCode != KeyEvent.KEYCODE_VOLUME_DOWN && 
          keyCode != KeyEvent.KEYCODE_MENU && 
          keyCode != KeyEvent.KEYCODE_CALL && 
          keyCode != KeyEvent.KEYCODE_ENDCALL; 
  if (isInPlaybackState() && isKeyCodeSupported && mMediaController != null) { 
   if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK || 
     keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) { 
    if (mMediaPlayer.isPlaying()) { 
     pause(); 
     mMediaController.show(); 
    } else { 
     start(); 
     mMediaController.hide(); 
    } 
    return true; 
   } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP 
     && mMediaPlayer.isPlaying()) { 
    pause(); 
    mMediaController.show(); 
   } else { 
    toggleMediaControlsVisiblity(); 
   } 
  } 
 
  return super.onKeyDown(keyCode, event); 
 } 
 
 private void toggleMediaControlsVisiblity() { 
  if (mMediaController.isShowing()) { 
   mMediaController.hide(); 
  } else { 
   mMediaController.show(); 
  } 
 } 
  
 public void start() { 
  if (isInPlaybackState()) { 
   mMediaPlayer.start(); 
   mCurrentState = STATE_PLAYING; 
  } 
  mTargetState = STATE_PLAYING; 
 } 
  
 public void pause() { 
  if (isInPlaybackState()) { 
   if (mMediaPlayer.isPlaying()) { 
    mMediaPlayer.pause(); 
    mCurrentState = STATE_PAUSED; 
   } 
  } 
  mTargetState = STATE_PAUSED; 
 } 
  
 // cache duration as mDuration for faster access 
 public int getDuration() { 
  if (isInPlaybackState()) { 
   if (mDuration > 0) { 
    return mDuration; 
   } 
   mDuration = mMediaPlayer.getDuration(); 
   return mDuration; 
  } 
  mDuration = -1; 
  return mDuration; 
 } 
  
 public int getCurrentPosition() { 
  if (isInPlaybackState()) { 
   return mMediaPlayer.getCurrentPosition(); 
  } 
  return 0; 
 } 
  
 public void seekTo(int msec) { 
  if (isInPlaybackState()) { 
   mMediaPlayer.seekTo(msec); 
   mSeekWhenPrepared = 0; 
  } else { 
   mSeekWhenPrepared = msec; 
  } 
 }  
    
 public boolean isPlaying() { 
  return isInPlaybackState() && mMediaPlayer.isPlaying(); 
 } 
  
 public int getBufferPercentage() { 
  if (mMediaPlayer != null) { 
   return mCurrentBufferPercentage; 
  } 
  return 0; 
 } 
 
 private boolean isInPlaybackState() { 
  return (mMediaPlayer != null && 
    mCurrentState != STATE_ERROR && 
    mCurrentState != STATE_IDLE && 
    mCurrentState != STATE_PREPARING); 
 } 
 
 public boolean canPause() { 
  return mCanPause; 
 } 
 
 public boolean canSeekBackward() { 
  return mCanSeekBack; 
 } 
 
 public boolean canSeekForward() { 
  return mCanSeekForward; 
 } 
}