Android游戏开发之九:VideoView类实例讲解

本节使用系统的示例类VideoView继续SurfaceView类相关内容的讲解，以让大家能更深入理解Android系统中图形绘制基础类的实现原理。也许你会发现无法改变VideoView类的控制方面，我们可以通过重构VideoView类来实现更加个性化的播放器。

创新互联服务项目包括利川网站建设、利川网站制作、利川网页制作以及利川网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，利川网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到利川省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

下面是VideoView类的相关代码。

 
 
    
  
  
  1.     public class VideoView extends SurfaceView implements MediaPlayerControl {    
    2.   
  
  2.         private String TAG = "VideoView";    
    3.   
  
  3.         // settable by the client    
    4.   
  
  4.         private Uri         mUri;    
    5.   
  
  5.         private int         mDuration;    
    6.   
  
  6.         // all possible internal states    
    7.   
  
  7.         private static final int STATE_ERROR              = -1;    
    8.   
  
  8.         private static final int STATE_IDLE               = 0;    
    9.   
  
  9.         private static final int STATE_PREPARING          = 1;    
    10.   
  
  10.         private static final int STATE_PREPARED           = 2;    
    11.   
  
  11.         private static final int STATE_PLAYING            = 3;    
    12.   
  
  12.         private static final int STATE_PAUSED             = 4;    
    13.   
  
  13.         private static final int STATE_PLAYBACK_COMPLETED = 5;    
    14.   
  
  14.         // mCurrentState is a VideoView object's current state.    
    15.   
  
  15.         // mTargetState is the state that a method caller intends to reach.    
    16.   
  
  16.         // For instance, regardless the VideoView object's current state,    
    17.   
  
  17.         // calling pause() intends to bring the object to a target state    
    18.   
  
  18.         // of STATE_PAUSED.    
    19.   
  
  19.         private int mCurrentState = STATE_IDLE;    
    20.   
  
  20.         private int mTargetState  = STATE_IDLE;    
    21.   
  
  21.         // All the stuff we need for playing and showing a video    
    22.   
  
  22.         private SurfaceHolder mSurfaceHolder = null;    
    23.   
  
  23.         private MediaPlayer mMediaPlayer = null;    
    24.   
  
  24.         private int         mVideoWidth;    
    25.   
  
  25.         private int         mVideoHeight;    
    26.   
  
  26.         private int         mSurfaceWidth;    
    27.   
  
  27.         private int         mSurfaceHeight;    
    28.   
  
  28.         private MediaController mMediaController;    
    29.   
  
  29.         private OnCompletionListener mOnCompletionListener;    
    30.   
  
  30.         private MediaPlayer.OnPreparedListener mOnPreparedListener;    
    31.   
  
  31.         private int         mCurrentBufferPercentage;    
    32.   
  
  32.         private OnErrorListener mOnErrorListener;    
    33.   
  
  33.         private int         mSeekWhenPrepared;  // recording the seek position while preparing    
    34.   
  
  34.         private boolean     mCanPause;    
    35.   
  
  35.         private boolean     mCanSeekBack;    
    36.   
  
  36.         private boolean     mCanSeekForward;    
    37.   
  
  37.         public VideoView(Context context) {    
    38.   
  
  38.             super(context);    
    39.   
  
  39.             initVideoView();    
    40.   
  
  40.         }    
    41.   
  
  41.         public VideoView(Context context, AttributeSet attrs) {    
    42.   
  
  42.             this(context, attrs, 0);    
    43.   
  
  43.             initVideoView();    
    44.   
  
  44.         }    
    45.   
  
  45.         public VideoView(Context context, AttributeSet attrs, int defStyle) {    
    46.   
  
  46.             super(context, attrs, defStyle);    
    47.   
  
  47.             initVideoView();    
    48.   
  
  48.         }    
    49.   
  
  49.         @Override   
    50.   
  
  50.         protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {    
    51.   
  
  51.             //Log.i("@@@@", "onMeasure");    
    52.   
  
  52.             int width = getDefaultSize(mVideoWidth, widthMeasureSpec);    
    53.   
  
  53.             int height = getDefaultSize(mVideoHeight, heightMeasureSpec);    
    54.   
  
  54.             if (mVideoWidth > 0 && mVideoHeight > 0) {    
    55.   
  
  55.                 if ( mVideoWidth * height  > width * mVideoHeight ) {    
    56.   
  
  56.                     //Log.i("@@@", "image too tall, correcting");    
    57.   
  
  57.                     height = width * mVideoHeight / mVideoWidth;    
    58.   
  
  58.                 } else if ( mVideoWidth * height  < width * mVideoHeight ) {    
    59.   
  
  59.                     //Log.i("@@@", "image too wide, correcting");    
    60.   
  
  60.                     width = height * mVideoWidth / mVideoHeight;    
    61.   
  
  61.                 } else {    
    62.   
  
  62.                     //Log.i("@@@", "aspect ratio is correct: " +    
    63.   
  
  63.                             //width+"/"+height+"="+    
    64.   
  
  64.                             //mVideoWidth+"/"+mVideoHeight);    
    65.   
  
  65.                 }    
    66.   
  
  66.             }    
    67.   
  
  67.             //Log.i("@@@@@@@@@@", "setting size: " + width + 'x' + height);    
    68.   
  
  68.             setMeasuredDimension(width, height);    
    69.   
  
  69.         }    
    70.   
  
  70.         public int resolveAdjustedSize(int desiredSize, int measureSpec) {    
    71.   
  
  71.             int result = desiredSize;    
    72.   
  
  72.             int specMode = MeasureSpec.getMode(measureSpec);    
    73.   
  
  73.             int specSize =  MeasureSpec.getSize(measureSpec);    
    74.   
  
  74.             switch (specMode) {    
    75.   
  
  75.                 case MeasureSpec.UNSPECIFIED:    
    76.   
  
  76.                     /* Parent says we can be as big as we want. Just don't be larger   
    77.   
  
  77.                      * than max size imposed on ourselves.   
    78.   
  
  78.                      */   
    79.   
  
  79.                     result = desiredSize;    
    80.   
  
  80.                     break;    
    81.   
  
  81.                 case MeasureSpec.AT_MOST:    
    82.   
  
  82.                     /* Parent says we can be as big as we want, up to specSize.    
    83.   
  
  83.                      * Don't be larger than specSize, and don't be larger than    
    84.   
  
  84.                      * the max size imposed on ourselves.   
    85.   
  
  85.                      */   
    86.   
  
  86.                     result = Math.min(desiredSize, specSize);    
    87.   
  
  87.                     break;    
    88.   
  
  88.                 case MeasureSpec.EXACTLY:    
    89.   
  
  89.                     // No choice. Do what we are told.    
    90.   
  
  90.                     result = specSize;    
    91.   
  
  91.                     break;    
    92.   
  
  92.             }    
    93.   
  
  93.             return result;    
    94.   
  
  94.     }    
    95.   
  
  95.         private void initVideoView() {    
    96.   
  
  96.             mVideoWidth = 0;    
    97.   
  
  97.             mVideoHeight = 0;    
    98.   
  
  98.             getHolder().addCallback(mSHCallback);    
    99.   
  
  99. getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);    
    100.   
  
  100.             setFocusable(true);    
    101.   
  
  101.             setFocusableInTouchMode(true);    
    102.   
  
  102.             requestFocus();    
    103.   
  
  103.             mCurrentState = STATE_IDLE;    
    104.   
  
  104.             mTargetState  = STATE_IDLE;    
    105.   
  
  105.         }    
    106.   
  
  106.         public void setVideoPath(String path) {    
    107.   
  
  107.             setVideoURI(Uri.parse(path));    
    108.   
  
  108.         }    
    109.   
  
  109.         public void setVideoURI(Uri uri) {    
    110.   
  
  110.             mUri = uri;    
    111.   
  
  111.             mSeekWhenPrepared = 0;    
    112.   
  
  112.             openVideo();    
    113.   
  
  113.             requestLayout();    
    114.   
  
  114.             invalidate();    
    115.   
  
  115.         }    
    116.   
  
  116.         public void stopPlayback() {    
    117.   
  
  117.             if (mMediaPlayer != null) {    
    118.   
  
  118.                 mMediaPlayer.stop();    
    119.   
  
  119.                 mMediaPlayer.release();    
    120.   
  
  120.                 mMediaPlayer = null;    
    121.   
  
  121.                 mCurrentState = STATE_IDLE;    
    122.   
  
  122.                 mTargetState  = STATE_IDLE;    
    123.   
  
  123.             }    
    124.   
  
  124.         }    
    125.   
  
  125.         private void openVideo() {    
    126.   
  
  126.             if (mUri == null || mSurfaceHolder == null) {    
    127.   
  
  127.                 // not ready for playback just yet, will try again later    
    128.   
  
  128.                 return;    
    129.   
  
  129.             }    
    130.   
  
  130.             // Tell the music playback service to pause     
    131.   
  
  131.             // TODO: these constants need to be published somewhere in the framework.    
    132.   
  
  132.             Intent i = new Intent("com.android.music.musicservicecommand");    
    133.   
  
  133.             i.putExtra("command", "pause");    
    134.   
  
  134.             mContext.sendBroadcast(i);    
    135.   
  
  135.             // we shouldn't clear the target state, because somebody might have    
    136.   
  
  136.             // called start() previously    
    137.   
  
  137.             release(false);    
    138.   
  
  138.             try {    
    139.   
  
  139.                 mMediaPlayer = new MediaPlayer();    
    140.   
  
  140. mMediaPlayer.setOnPreparedListener(mPreparedListener);    
    141.   
  
  141. mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener);  
    142.   
  
  142.                 mDuration = -1;    
    143.   
  
  143. mMediaPlayer.setOnCompletionListener(mCompletionListener);    
    144.   
  
  144. mMediaPlayer.setOnErrorListener(mErrorListener);    
    145.   
  
  145. mMediaPlayer.setOnBufferingUpdateListener(mBufferingUpdateListener);    
    146.   
  
  146.                 mCurrentBufferPercentage = 0;    
    147.   
  
  147.                 mMediaPlayer.setDataSource(mContext, mUri);    
    148.   
  
  148.                 mMediaPlayer.setDisplay(mSurfaceHolder);   mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);    
    149.   
  
  149.                 mMediaPlayer.setScreenOnWhilePlaying(true);    
    150.   
  
  150.                 mMediaPlayer.prepareAsync();    
    151.   
  
  151.                 // we don't set the target state here either, but preserve the    
    152.   
  
  152.                 // target state that was there before.    
    153.   
  
  153.                 mCurrentState = STATE_PREPARING;    
    154.   
  
  154.                 attachMediaController();    
    155.   
  
  155.             } catch (IOException ex) {    
    156.   
  
  156.                 Log.w(TAG, "Unable to open content: " + mUri, ex);    
    157.   
  
  157.                 mCurrentState = STATE_ERROR;    
    158.   
  
  158.                 mTargetState = STATE_ERROR;    
    159.   
  
  159.                 mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);    
    160.   
  
  160.                 return;    
    161.   
  
  161.             } catch (IllegalArgumentException ex) {    
    162.   
  
  162.                 Log.w(TAG, "Unable to open content: " + mUri, ex);    
    163.   
  
  163.                 mCurrentState = STATE_ERROR;    
    164.   
  
  164.                 mTargetState = STATE_ERROR;    
    165.   
  
  165.                 mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);    
    166.   
  
  166.                 return;    
    167.   
  
  167.             }    
    168.   
  
  168.         }    
    169.   
  
  169.         public void setMediaController(MediaController controller) {    
    170.   
  
  170.             if (mMediaController != null) {    
    171.   
  
  171.                 mMediaController.hide();    
    172.   
  
  172.             }    
    173.   
  
  173.             mMediaController = controller;    
    174.   
  
  174.             attachMediaController();    
    175.   
  
  175.         }    
    176.   
  
  176.         private void attachMediaController() {    
    177.   
  
  177.             if (mMediaPlayer != null && mMediaController != null) {    
    178.   
  
  178.                 mMediaController.setMediaPlayer(this);    
    179.   
  
  179.                 View anchorView = this.getParent() instanceof View ?    
    180.   
  
  180.                         (View)this.getParent() : this;    
    181.   
  
  181.                 mMediaController.setAnchorView(anchorView);   mMediaController.setEnabled(isInPlaybackState());    
    182.   
  
  182.             }    
    183.   
  
  183.         }    
    184.   
  
  184.         MediaPlayer.OnVideoSizeChangedListener mSizeChangedListener =    
    185.   
  
  185.             new MediaPlayer.OnVideoSizeChangedListener() {    
    186.   
  
  186.                 public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {    
    187.   
  
  187.                     mVideoWidth = mp.getVideoWidth();    
    188.   
  
  188.                     mVideoHeight = mp.getVideoHeight();    
    189.   
  
  189.                     if (mVideoWidth != 0 && mVideoHeight != 0) {    
    190.   
  
  190.                         getHolder().setFixedSize(mVideoWidth, mVideoHeight);    
    191.   
  
  191.                     }    
    192.   
  
  192.                 }    
    193.   
  
  193.         };    
    194.   
  
  194.         MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {    
    195.   
  
  195.             public void onPrepared(MediaPlayer mp) {    
    196.   
  
  196.                 mCurrentState = STATE_PREPARED;    
    197.   
  
  197.                 // Get the capabilities of the player for this stream    
    198.   
  
  198.                 Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL,    
    199.   
  
  199.                                           MediaPlayer.BYPASS_METADATA_FILTER);    
    200.   
  
  200.                 if (data != null) {    
    201.   
  
  201.                     mCanPause = !data.has(Metadata.PAUSE_AVAILABLE)    
    202.   
  
  202.                             || data.getBoolean(Metadata.PAUSE_AVAILABLE);    
    203.   
  
  203.                     mCanSeekBack = !data.has(Metadata.SEEK_BACKWARD_AVAILABLE)    
    204.   
  
  204.                             || data.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE);    
    205.   
  
  205.                     mCanSeekForward = !data.has(Metadata.SEEK_FORWARD_AVAILABLE)    
    206.   
  
  206.                             || data.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE);    
    207.   
  
  207.                 } else {    
    208.   
  
  208.                     mCanPause = mCanSeekForward = mCanSeekForward = true;    
    209.   
  
  209.                 }    
    210.   
  
  210.                 if (mOnPreparedListener != null) {    
    211.   
  
  211.                     mOnPreparedListener.onPrepared(mMediaPlayer);    
    212.   
  
  212.                 }    
    213.   
  
  213.                 if (mMediaController != null) {    
    214.   
  
  214.                     mMediaController.setEnabled(true);    
    215.   
  
  215.                 }    
    216.   
  
  216.                 mVideoWidth = mp.getVideoWidth();    
    217.   
  
  217.                 mVideoHeight = mp.getVideoHeight();    
    218.   
  
  218.                 int seekToPosition = mSeekWhenPrepared;  // mSeekWhenPrepared may be changed after seekTo() call    
    219.   
  
  219.                 if (seekToPosition != 0) {    
    220.   
  
  220.                     seekTo(seekToPosition);    
    221.   
  
  221.                 }    
    222.   
  
  222.                 if (mVideoWidth != 0 && mVideoHeight != 0) {    
    223.   
  
  223.                     //Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight);    
    224.   
  
  224.                     getHolder().setFixedSize(mVideoWidth, mVideoHeight);    
    225.   
  
  225.                     if (mSurfaceWidth == mVideoWidth && mSurfaceHeight == mVideoHeight) {    
    226.   
  
  226.                         // We didn't actually change the size (it was already at the size    
    227.   
  
  227.                         // we need), so we won't get a "surface changed" callback, so    
    228.   
  
  228.                         // start the video here instead of in the callback.    
    229.   
  
  229.                         if (mTargetState == STATE_PLAYING) {    
    230.   
  
  230.                             start();    
    231.   
  
  231.                             if (mMediaController != null) {    
    232.   
  
  232.                                 mMediaController.show();    
    233.   
  
  233.                             }    
    234.   
  
  234.                         } else if (!isPlaying() &&    
    235.   
  
  235.                                    (seekToPosition != 0 || getCurrentPosition() > 0)) {    
    236.   
  
  236.                            if (mMediaController != null) {    
    237.   
  
  237.                                // Show the media controls when we're paused into a video and make 'em stick.    
    238.   
  
  238.                                mMediaController.show(0);    
    239.   
  
  239.                            }    
    240.   
  
  240.                        }    
    241.   
  
  241.                     }    
    242.   
  
  242.                 } else {    
    243.   
  
  243.                     // We don't know the video size yet, but should start anyway.    
    244.   
  
  244.                     // The video size might be reported to us later.    
    245.   
  
  245.                     if (mTargetState == STATE_PLAYING) {    
    246.   
  
  246.                         start();    
    247.   
  
  247.                     }    
    248.   
  
  248.                 }    
    249.   
  
  249.             }    
    250.   
  
  250.         };    
    251.   
  
  251.         private MediaPlayer.OnCompletionListener mCompletionListener =    
    252.   
  
  252.             new MediaPlayer.OnCompletionListener() {    
    253.   
  
  253.             public void onCompletion(MediaPlayer mp) {    
    254.   
  
  254.                 mCurrentState = STATE_PLAYBACK_COMPLETED;    
    255.   
  
  255.                 mTargetState = STATE_PLAYBACK_COMPLETED;    
    256.   
  
  256.                 if (mMediaController != null) {    
    257.   
  
  257.                     mMediaController.hide();    
    258.   
  
  258.                 }    
    259.   
  
  259.                 if (mOnCompletionListener != null) {   mOnCompletionListener.onCompletion(mMediaPlayer);    
    260.   
  
  260.                 }    
    261.   
  
  261.             }    
    262.   
  
  262.         };    
    263.   
  
  263.         private MediaPlayer.OnErrorListener mErrorListener =    
    264.   
  
  264.             new MediaPlayer.OnErrorListener() {    
    265.   
  
  265.             public boolean onError(MediaPlayer mp, int framework_err, int impl_err) {    
    266.   
  
  266.                 Log.d(TAG, "Error: " + framework_err + "," + impl_err);    
    267.   
  
  267.                 mCurrentState = STATE_ERROR;    
    268.   
  
  268.                 mTargetState = STATE_ERROR;    
    269.   
  
  269.                 if (mMediaController != null) {    
    270.   
  
  270.                     mMediaController.hide();    
    271.   
  
  271.                 }    
    272.   
  
  272.                 /* If an error handler has been supplied, use it and finish. */   
    273.   
  
  273.                 if (mOnErrorListener != null) {    
    274.   
  
  274.                     if (mOnErrorListener.onError(mMediaPlayer, framework_err, impl_err)) {    
    275.   
  
  275.                         return true;    
    276.   
  
  276.                     }    
    277.   
  
  277.                 }    
    278.   
  
  278.                 /* Otherwise, pop up an error dialog so the user knows that   
    279.   
  
  279.                  * something bad has happened. Only try and pop up the dialog   
    280.   
  
  280.                  * if we're attached to a window. When we're going away and no   
    281.   
  
  281.                  * longer have a window, don't bother showing the user an error.   
    282.   
  
  282.                  */   
    283.   
  
  283.                 if (getWindowToken() != null) {    
    284.   
  
  284.                     Resources r = mContext.getResources();    
    285.   
  
  285.                     int messageId;    
    286.   
  
  286.                     if (framework_err == MediaPlayer.MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK) {    
    287.   
  
  287.                         messageId = com.android.internal.R.string.VideoView_error_text_invalid_progressive_playback;    
    288.   
  
  288.                     } else {    
    289.   
  
  289.                         messageId = com.android.internal.R.string.VideoView_error_text_unknown;    
    290.   
  
  290.                     }    
    291.   
  
  291.                     new AlertDialog.Builder(mContext)    
    292.   
  
  292. .setTitle(com.android.internal.R.string.VideoView_error_title)    
    293.   
  
  293.                             .setMessage(messageId)    
    294.   
  
  294.                             .setPositiveButton(com.android.internal.R.string.VideoView_error_button,    
    295.   
  
  295.                                     new DialogInterface.OnClickListener() {    
    296.   
  
  296.                                         public void onClick(DialogInterface dialog, int whichButton) {    
    297.   
  
  297.                                             /* If we get here, there is no onError listener, so   
    298.   
  
  298.                                              * at least inform them that the video is over.   
    299.   
  
  299.                                              */   
    300.   
  
  300.                                             if (mOnCompletionListener != null) {    
    301.   
  
  301. mOnCompletionListener.onCompletion(mMediaPlayer);    
    302.   
  
  302.                                             }    
    303.   
  
  303.                                         }    
    304.   
  
  304.                                     })    
    305.   
  
  305.                             .setCancelable(false)    
    306.   
  
  306.                             .show();    
    307.   
  
  307.                 }    
    308.   
  
  308.                 return true;    
    309.   
  
  309.             }    
    310.   
  
  310.         };    
    311.   
  
  311.         private MediaPlayer.OnBufferingUpdateListener mBufferingUpdateListener =    
    312.   
  
  312.             new MediaPlayer.OnBufferingUpdateListener() {    
    313.   
  
  313.             public void onBufferingUpdate(MediaPlayer mp, int percent) {    
    314.   
  
  314.                 mCurrentBuffe            
    
                当前名称：Android游戏开发之九:VideoView类实例讲解
                
    
                地址分享：http://www.shufengxianlan.com/qtweb/news5/244955.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

软件开发知识

同城分类信息

成都二枢机房　　 　南充护栏钻孔机　　 　四川审计公司　　 　响应式网站设计　　 　网络营销公司　　 　成都网站建设　　 　微博营销　　 　广汉锦华　　 　普能电气　　 　大吉雪茄　　 　域名注册　　 　广东帝美豪门窗　　 　电商网站建设　　 　做网站设计　　 　班戈纳美网站　　 　app软件开发　　 　网站推广　　 　ssl证书申请　　 　seo优化　　 　成都小程序制作