ultragtx – 第 9 页

Android Dev：VideoView源代码浅析及拓展应用

做Android开发不免要涉及到编写媒体播放器，对于初学者来说用MediaPlayer实现一个具有基本功能的播放器（有进度条，可以通过进度条上的按钮进行控制）还是有一定难度的，幸好Android还提供了一个VideoView类，借用该类可以快速实现简单的媒体播放功能，其源代码如下（单击右边那个箭头展开）：

```
/*
```

 * Copyright (C) 2006 The Android Open Source Project

```
 *
```

 * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);

 * 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 &quot;AS IS&quot; 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 android.widget;
```
```
 
```
```
import android.app.AlertDialog;
```
```
import android.content.Context;
```
```
import android.content.DialogInterface;
```
```
import android.content.Intent;
```
```
import android.content.res.Resources;
```
```
import android.media.AudioManager;
```
```
import android.media.MediaPlayer;
```
```
import android.media.Metadata;
```

import android.media.MediaPlayer.OnCompletionListener;

import android.media.MediaPlayer.OnErrorListener;

```
import android.net.Uri;
```
```
import android.os.PowerManager;
```
```
import android.util.AttributeSet;
```
```
import android.util.Log;
```
```
import android.view.KeyEvent;
```
```
import android.view.MotionEvent;
```
```
import android.view.SurfaceHolder;
```
```
import android.view.SurfaceView;
```
```
import android.view.View;
```

import android.widget.MediaController.*;

```
 
```
```
import java.io.IOException;
```
```
import java.util.Map;
```
```
 
```
```
/**
```

 * Displays a video file.  The VideoView class

 * can load images from various sources (such as resources or content

 * providers), takes care of computing its measurement from the video so that

 * it can be used in any layout manager, and provides various display options

```
 * such as scaling and tinting.
```
```
 */
```

public class VideoView extends SurfaceView implements MediaPlayerControl {

    private String TAG = &quot;VideoView&quot;;

```
    // settable by the client
```
```
    private Uri         mUri;
```

    private Map<string, string=""> mHeaders;

```
    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;

    private static final int STATE_SUSPEND            = 6;

    private static final int STATE_RESUME             = 7;

    private static final int STATE_SUSPEND_UNSUPPORTED = 8;

```
 
```

    // mCurrentState is a VideoView object&#39;s current state.

    // mTargetState is the state that a method caller intends to reach.

    // For instance, regardless the VideoView object&#39;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;

    private int         mStateWhenSuspended;  //state before calling suspend()

```
 
```
```
    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(&quot;@@@@&quot;, &quot;onMeasure&quot;);

        int width = getDefaultSize(mVideoWidth, widthMeasureSpec);

        int height = getDefaultSize(mVideoHeight, heightMeasureSpec);

        if (mVideoWidth &gt; 0 &amp;&amp; mVideoHeight &gt; 0) {

            if ( mVideoWidth * height  &gt; width * mVideoHeight ) {

                //Log.i(&quot;@@@&quot;, &quot;image too tall, correcting&quot;);

                height = width * mVideoHeight / mVideoWidth;

            } else if ( mVideoWidth * height  &lt; width * mVideoHeight ) {

                //Log.i(&quot;@@@&quot;, &quot;image too wide, correcting&quot;);

                width = height * mVideoWidth / mVideoHeight;

```
            } else {
```

                //Log.i(&quot;@@@&quot;, &quot;aspect ratio is correct: &quot; +

                        //width+&quot;/&quot;+height+&quot;=&quot;+

                        //mVideoWidth+&quot;/&quot;+mVideoHeight);

```
            }
```
```
        }
```

        //Log.i(&quot;@@@@@@@@@@&quot;, &quot;setting size: &quot; + width + &#39;x&#39; + 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:

                /* Parent says we can be as big as we want. Just don&#39;t be larger

                 * than max size imposed on ourselves.

```
                 */
```
```
                result = desiredSize;
```
```
                break;
```
```
 
```
```
            case MeasureSpec.AT_MOST:
```

                /* Parent says we can be as big as we want, up to specSize.

                 * Don&#39;t be larger than specSize, and don&#39;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) {
```
```
        setVideoURI(uri, null);
```
```
    }
```
```
 
```
```
    /**
```
```
     * @hide
```
```
     */
```

    public void setVideoURI(Uri uri, Map<string, string=""> headers) {

```
        mUri = uri;
```
```
        mHeaders = headers;
```
```
        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(&quot;com.android.music.musicservicecommand&quot;);

        i.putExtra(&quot;command&quot;, &quot;pause&quot;);

```
        mContext.sendBroadcast(i);
```
```
 
```

        // we shouldn&#39;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, mHeaders);

            mMediaPlayer.setDisplay(mSurfaceHolder);

            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

            mMediaPlayer.setScreenOnWhilePlaying(true);

            mMediaPlayer.prepareAsync();

            // we don&#39;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, &quot;Unable to open content: &quot; + mUri, ex);

            mCurrentState = STATE_ERROR;

```
            mTargetState = STATE_ERROR;
```

            mErrorListener.onError(mMediaPlayer, MediaPlayer.MEDIA_ERROR_UNKNOWN, 0);

```
            return;
```

        } catch (IllegalArgumentException ex) {

            Log.w(TAG, &quot;Unable to open content: &quot; + 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 &amp;&amp; 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 &amp;&amp; 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 = mCanSeekBack = 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 &amp;&amp; mVideoHeight != 0) {

                //Log.i(&quot;@@@@&quot;, &quot;video size: &quot; + mVideoWidth +&quot;/&quot;+ mVideoHeight);

                getHolder().setFixedSize(mVideoWidth, mVideoHeight);

                if (mSurfaceWidth == mVideoWidth &amp;&amp; mSurfaceHeight == mVideoHeight) {

                    // We didn&#39;t actually change the size (it was already at the size

                    // we need), so we won&#39;t get a &quot;surface changed&quot; callback, so

                    // start the video here instead of in the callback.

                    if (mTargetState == STATE_PLAYING) {

```
                        start();
```

                        if (mMediaController != null) {

                            mMediaController.show();

```
                        }
```

                    } else if (!isPlaying() &amp;&amp;

                               (seekToPosition != 0 || getCurrentPosition() &gt; 0)) {

                       if (mMediaController != null) {

                           // Show the media controls when we&#39;re paused into a video and make &#39;em stick.

                           mMediaController.show(0);

```
                       }
```
```
                   }
```
```
                }
```
```
            } else {
```

                // We don&#39;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, &quot;Error: &quot; + framework_err + &quot;,&quot; + 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&#39;re attached to a window. When we&#39;re going away and no

             * longer have a window, don&#39;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 &amp;&amp; mVideoHeight == h);

            if (mMediaPlayer != null &amp;&amp; isValidState &amp;&amp; hasValidSize) {

                if (mSeekWhenPrepared != 0) {

                    seekTo(mSeekWhenPrepared);

```
                }
```
```
                start();
```

                if (mMediaController != null) {

                    mMediaController.show();

```
                }
```
```
            }
```
```
        }
```
```
 
```

        public void surfaceCreated(SurfaceHolder holder)

```
        {
```
```
            mSurfaceHolder = holder;
```

            //resume() was called before surfaceCreated()

            if (mMediaPlayer != null &amp;&amp; mCurrentState == STATE_SUSPEND

                   &amp;&amp; mTargetState == STATE_RESUME) {

                mMediaPlayer.setDisplay(mSurfaceHolder);

```
                resume();
```
```
            } else {
```
```
                openVideo();
```
```
            }
```
```
        }
```
```
 
```

        public void surfaceDestroyed(SurfaceHolder holder)

```
        {
```

            // after we return from this we can&#39;t use the surface any more

```
            mSurfaceHolder = null;
```

            if (mMediaController != null) mMediaController.hide();

            if (mCurrentState != STATE_SUSPEND) {

```
                release(true);
```
```
            }
```
```
        }
```
```
    };
```
```
 
```
```
    /*
```

     * release the media player in any state

```
     */
```

    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() &amp;&amp; mMediaController != null) {

            toggleMediaControlsVisiblity();

```
        }
```
```
        return false;
```
```
    }
```
```
 
```
```
    @Override
```

    public boolean onTrackballEvent(MotionEvent ev) {

        if (isInPlaybackState() &amp;&amp; mMediaController != null) {

            toggleMediaControlsVisiblity();

```
        }
```
```
        return false;
```
```
    }
```
```
 
```
```
    @Override
```

    public boolean onKeyDown(int keyCode, KeyEvent event)

```
    {
```

        boolean isKeyCodeSupported = keyCode != KeyEvent.KEYCODE_BACK &amp;&amp;

                                     keyCode != KeyEvent.KEYCODE_VOLUME_UP &amp;&amp;

                                     keyCode != KeyEvent.KEYCODE_VOLUME_DOWN &amp;&amp;

                                     keyCode != KeyEvent.KEYCODE_MENU &amp;&amp;

                                     keyCode != KeyEvent.KEYCODE_CALL &amp;&amp;

                                     keyCode != KeyEvent.KEYCODE_ENDCALL;

        if (isInPlaybackState() &amp;&amp; isKeyCodeSupported &amp;&amp; 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

                    &amp;&amp; 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;
```
```
    }
```
```
 
```
```
    public void suspend() {
```
```
        if (isInPlaybackState()) {
```

            if (mMediaPlayer.suspend()) {

                mStateWhenSuspended = mCurrentState;

                mCurrentState = STATE_SUSPEND;

                mTargetState = STATE_SUSPEND;

```
            } else {
```
```
                release(false);
```

                mCurrentState = STATE_SUSPEND_UNSUPPORTED;

                Log.w(TAG, &quot;Unable to suspend video. Release MediaPlayer.&quot;);

```
            }
```
```
        }
```
```
    }
```
```
 
```
```
    public void resume() {
```

        if (mSurfaceHolder == null &amp;&amp; mCurrentState == STATE_SUSPEND){

            mTargetState = STATE_RESUME;

```
            return;
```
```
        }
```

        if (mMediaPlayer != null &amp;&amp; mCurrentState == STATE_SUSPEND) {

            if (mMediaPlayer.resume()) {

                mCurrentState = mStateWhenSuspended;

                mTargetState = mStateWhenSuspended;

```
            } else {
```

                Log.w(TAG, &quot;Unable to resume video&quot;);

```
            }
```
```
            return;
```
```
        }
```

        if (mCurrentState == STATE_SUSPEND_UNSUPPORTED) {

```
            openVideo();
```
```
        }
```
```
    }
```
```
 
```

   // cache duration as mDuration for faster access

```
    public int getDuration() {
```
```
        if (isInPlaybackState()) {
```
```
            if (mDuration &gt; 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() &amp;&amp; mMediaPlayer.isPlaying();

```
    }
```
```
 
```
```
    public int getBufferPercentage() {
```
```
        if (mMediaPlayer != null) {
```

            return mCurrentBufferPercentage;

```
        }
```
```
        return 0;
```
```
    }
```
```
 
```

    private boolean isInPlaybackState() {

        return (mMediaPlayer != null &amp;&amp;

                mCurrentState != STATE_ERROR &amp;&amp;

                mCurrentState != STATE_IDLE &amp;&amp;

                mCurrentState != STATE_PREPARING);

```
    }
```
```
 
```
```
    public boolean canPause() {
```
```
        return mCanPause;
```
```
    }
```
```
 
```
```
    public boolean canSeekBackward() {
```
```
        return mCanSeekBack;
```
```
    }
```
```
 
```
```
    public boolean canSeekForward() {
```
```
        return mCanSeekForward;
```
```
    }
```
```
}
```
```
</string,></string,>
```

继续阅读Android Dev：VideoView源代码浅析及拓展应用

解决Mac OS不能更新，下载更新速度慢的方法

更新Again：80.67.74.160这个ip好像已经ping不通了，如果之前修改了hosts，删除hosts中添加的那一行就行，更新应该也正常了。教育网内速度当然就又慢下来，正在实验这个ip是否能快点60.254.175.32，以下是dig出来的ip，仅供参考

60.254.175.23

60.254.175.22

125.56.202.7

125.56.202.12

121.248.156.7

—————————————————————————

~~更新：似乎在教育网内好用，教育网外可能反而无法更新~~

不知道用Mac的各位有没有遇到这两种情况：

打开iTunes/iWork，提示有新版本，点击升级，跳转到软件更新程序，检查了半天居然说你的软件是最新版。
下载更新速度奇慢，估计也就几K，一个更新能下一天，有时还有错误要重新下载。

如果你符合以上两种情况那么只需要执行一下几步就可以轻松解决

打开终端，sudo /Applications/TextEdit.app/Contents/MacOS/TextEdit /etc/hosts，然后可能有提示要输入你的密码，TextEdit会打开hosts文件让你编辑
在这个文件里添加一行：80.67.74.160 swcdn.apple.com 注意保存

就这么简单，之后更新就应该恢复正常了，下载速度也比原来强百倍，如果想知道更多细节参见这篇文章

PS：这个方法应该早就有了，我用了这么长时间mac居然没发现，真是罪过啊！

Intel超赞新Core i5广告

The Chase Film

废话少说，直接上视频（如果一直转圈不播放的话尝试拖动一下进度条）

话说，怎么不弄个Mac版的。

Mac OS 下命令行编辑plist的方法

一般我们编辑plist文件都是直接打开，用PlistEditor什么的进行可视化编辑，但是如果想用脚本编辑plist文件就要用到命令行了，其实这是一个很简单的命令：defaults

defaults 命令的帮助如下

'defaults' [-currentHost | -host ] followed by one of the following:

  read                                 shows all defaults
  read                         shows defaults for given domain
  read                    shows defaults for given domain, key

  read-type               shows the type for the given domain, key

  write            writes domain (overwrites existing)
  write            writes key for domain

  rename 
   renames old_key to new_key

  delete                       deletes domain
  delete                  deletes key in domain

  domains                              lists all domains
  find                           lists all entries containing word
  help                                 print this help

 is (  | -app  | -globalDomain )
         or a path to a file omitting the '.plist' extension

 is one of:
  
  -string 
  -data 
  -int[eger] 
  -float  
  -bool[ean] (true | false | yes | no)
  -date 
  -array   ...
  -array-add   ...
  -dict     ...
  -dict-add   …

光看这些就大概知道怎么弄了吧，下面是几个例子：

defaults read com.xxx.xxx // 输出文件中所有信息
defaults write com.xxx.xxx   // 改变某个key的value，如果没有该key则添�

注意：在 "com.xxx.xxx" 之后没有 ".plist"，开始我犯了这个错误，弄半天不知道为何plist文件中的值没有改变。

（END）

[转载]Unix-Center.Net需要您的帮助

以下内容是原文，推荐直接访问原网站：

我恳请诸位花一点时间读完这篇文章，因为将有数以万计的人会从您的爱心中得到帮助。

Unix-Center.Net的目标是为研究、学习和使用各种版本的Unix和类Unix操作系统的教师、学生和工程技术人员提供一个体验和测试各种版本的Unix和类Unix系统的软硬件平台。该平台能够为所有注册用户免费提供SSH/VNC服务，MySQL数据库服务，传统的C/C++、Java、Fortran等多种语言开发环境，基于Apache、MySQL和PHP的Web应用开发环境。简单地讲，Unix-Center.Net的注册用户可以远程登录进入多个不同的操作系统，具备自己独立的用户空间和磁盘配额，享受该操作系统上普通用户的所有权限，学习和使用各种版本的Unix和类Unix操作系统的常用命令和功能，可以将自己正在开发的应用程序上载到Unix体验中心的服务器，在不同的软硬件平台上编译和运行。

到目前为止，Unix-Center.Net所提供的操作系统包括AIX 5.3，Solaris 10，OpenSolaris 2009.06，Fedora Core 10，Ubuntu 8.04，FreeBSD 6.2，Debian Linux for MIPS。这些操作系统分别运行在IBM Power 5，Sun UltraSPARC T1，AMD Opteron，Intel Xeon，龙芯2E等不同构架的处理器上。各种各样的服务器，再加上交换机、防火墙、存储等等，Unix-Center.Net的全部设备需要整整三个机柜才能够装得下。

继续阅读[转载]Unix-Center.Net需要您的帮助

修改Mac下粘贴并匹配样式的快捷键

Mac下的粘贴功能很“智能”，可以把原来的格式文字原封不动的搬过来，但这样也照成一些麻烦，如乱码，格式混乱等，Mac下还有另一种粘贴方式即“粘贴并匹配样式”（Paste And Match Sytle），这种粘贴方式所”匹配“的样式不是原文的样式，而是要粘贴到的位置的样式，但这种粘贴方法要同时按下“⇧⌘⌥V”这四个按键，实在是有点困难，而对我来讲还是这种粘贴方式更加符合我的工作习惯。解决方法很明确，就是将两种粘贴方式的快捷键互换一下，这样能很好的保证不会与其他快捷键有冲突，方法如下：

打开偏好设置>>键盘>>键盘快捷键
在左边的列表里选择“应用程序快捷键”，然后点下面那个“+”号添加一项
在弹出的对话框中，“应用程序”选则你要修改的程序，尽量不要选择全部程序，因为某些程序没有匹配样式并粘贴这个操作（比如终端，Mac QQ等），这样就会导致粘贴时必须按⇧⌘⌥+V才行（如果一定要选择所有程序，要么就单独为那些出问题的程序把粘贴这一操作的快捷键设置成⌘+v，要么就使用别的快捷键），“菜单标题”输入“粘贴”，“键盘快捷键”⇧⌘⌥+v，点添加。
再用相同的方法添加“粘贴并匹配样式”，快捷键“⌘+v”，如果某些英文软件不支持中文，还要添加“Paste”和“Paste And Match Style"，方法类似。

OK，修改完成，现在可以开个程序试试修改的效果了。（END）

Apple岁末广告攻势

Apple这样一家大公司之所以如此成功，当然少不了广告的作用，下面是笔者在2010年年末收到的apple广告邮件截图，与大家分享一下，共同体验Apple的强大。

这一段的广告与往日不同，采用了红色的文字和按钮，完美展现出节日的气氛。

11月16日，应该是这一波广告攻势的第一封mail吧，涵盖了Apple2010年的主要产品：iPad、Air、Touch、iPhone、Apple TV

继续阅读Apple岁末广告攻势

Mac OS X Snow Leopard 64bit下使用ipv6的方法

需要一个软件Teredo(Miredo), 安装后在系统偏好设置里, 下载地址

Teredo我就不介绍了, 如果真的不知道就自己查下吧, 这篇文章主要解决64bit下Teredo不能获得ipv6地址的问题. 可以额外参考这篇文章(EN).

这个版本的Teredo只能工作在32bit下, 64bit无法获得ipv6地址, 现象是Teredo设置界面Teredo Tunnel那一项后面那个圆点(指示灯)总不是绿的(好像是黄的, 如果关闭Teredo后是红的), 高手可以尝试下载源代码自行编译修改. 懒人可以接着往下看解决方法:

这里需要安装另一个东西–TunTap , 到这里下载, 我提供的地址是20090913版的,如果有更新请在附近查找, 安装后可以发现Teredo设置里面上面提到的指示灯变绿色了, 下面的Teredo Address也有信息了, 是你获取的ipv6地址, 如果还是不行试试把那个server换了, 微软那个我这里不能连接上, teredo.remlab.net目前好用. 如果还是不行, 请留言. (END)

更新几个服务器：

Public teredo servers:

* teredo.remlab.net / teredo-debian.remlab.net (France)

* teredo.autotrans.consulintel.com (Spain)

* teredo.ipv6.microsoft.com (USA, Redmond) (default for WindowsXP/2003/Vista/2008 OS)

* teredo.ngix.ne.kr (South Korea)

* teredo.managemydedi.com (USA, Chicago)

* teredo.trex.fi (Finland)

Godaddy免费空间发送邮件方法

原文是英文版，还被墙了，我在这转载并翻译一下，不能保证与原文的更新同步，该精简的我也了精简一下，如有需要我可以把原文贴出来。

要知道Godaddy的免费空间禁用了mail()函数，无法通过调用mail()发送邮件，因此一些有关功能就无法使用，比如wp-db-backup插件的定期备份数据库并发送至指定邮箱的功能。下面这种方法可以解决该问题。

下载插件WP Mail SMTP，这个直接在后台就可以安装。
建立一个Godaddy的E-mail帐号，这个似乎只要你买了域名或者空间就可以免费获得，不过要自己去开通一下。如果你已经开通并有一个帐号了就不必再申请了。
进入后台“设置”–“EMail”，按如下方法填写：

From Email: 按这种格式填写“[email protected]"，注意必须是刚才注册那个Godaddy的email帐号
From Name：应该随便填，就是现实是谁发的邮件，留空则发件人是wordpress
Mailer：选择“Send all WordPress emails via SMTP”
SMTP Host：填写“relay-hosting.secureserver.net”
SMTP Port：填写“25”（这是默认SMTP端口）
Encryption：选择“No encryption“
Authentication：选择”No: Do not use SMTP authentication“，下面那个用户名密码不用填

之后的工作：

点Update Options按钮保存
在最下面那个框填写一个你的email，点Send Test按钮测试一下

如果成功了将出现以下信息(点击右边那个按钮展开)

Test Message Sent
 
The result was:
 
bool(true)
The SMTP debugging output is shown below:
 
SMTP -&gt; FROM SERVER:
220 p3nlsmtp01.shr.prod.phx3.secureserver.net ESMTP
SMTP -&gt; FROM SERVER:
250-p3nlsmtp01.shr.prod.phx3.secureserver.net
250-PIPELINING
250-SIZE 31457280
250 8BITMIME
SMTP -&gt; FROM SERVER:
250 ok
SMTP -&gt; FROM SERVER:
250 ok
SMTP -&gt; FROM SERVER:
354 go ahead punk, make my day
SMTP -&gt; FROM SERVER:
250 ok 1292396492 qp 31062 by p3nlsmtp01.shr.prod.phx3.secureserver.net
SMTP -&gt; FROM SERVER:
221 p3nlsmtp01.shr.prod.phx3.secureserver.net Goodbye.

眼花缭乱是吗？其实直接看第5行那个bool(true)就行，如果是true就表示成功了

LongTimeNoC 主题确定

经过几番周折，本博客终于确定了主题–Suffusion，先后测试了Mystique、Twenty Ten、LightWord、Atahualpa等多款主题，发现不是功能不好，定制性不强，中文支持不完善，就是太大众化，随便找几个wordpress的博客，能有一裤兜字用一个主题的，样式还挺统一的（如果可定制性强就不怕变得太大众化了）。这些主题中Atahualpa给我留下很深刻的印象，可定制性太强了，后台设置可以用眼花缭乱来形容，最终还是因RSS Feed中文乱码问题而放弃了。Suffusion，也就是现在这个主题最开始我安装过一遍，看到后台主题那部分没有设置选项就直接换成别的主题了，今天又安装了一次突然发现该主题的后台设置原来在后台的最底部，其可定制程度虽不能和Atahualpa相比，但也确实够丰富了，具体还是由读者来发现吧。主题下载直接在wordpress的主题安装中搜索即可，后台设置是英文版的，有网友对其做了汉化（本文发布时是3.7.1版，和最新版同步），汉化得很不错，下载页面。

Suffusion作者博客：http://www.aquoid.com/news/