教程 – 第 4 页 – LongTimeNoC

XCode技巧之UserScripts

XCode作为一款强大的IDE，当然也支持脚本功能。通过添加自己的脚本我们可以很方便的完成我们的工作。

在XCode中点击 Edit User Scripts即可方便的添加脚本，而且XCode自带的脚本也相当于给我们提供了丰富的样例。

比如我们添加一个这样的脚本，并为其添加一个快捷键⇧⌘P（快捷键添加方法参考Comments分类中的Un/Comment Selection脚本）

#!/bin/sh

echo "%%%{PBXSelection}%%%"
echo "#pragma mark -"
echo "#pragma mark %%%{PBXSelectedText}%%%"
echo "%%%{PBXSelection}%%%"

注意在Output下拉列表中选择Replace Selection。这个脚本的作用是方便我们建立#pragma，首先提供pragma的名字，然后选中这个名字，按相应快捷键，#pragma就自动完成了，很方便。

这个脚本也可以这样写，我们就不用每行都写echo了

#!/bin/sh

cat << EOF
%%%{PBXSelection}%%%
#pragma mark -
#pragma mark %%%{PBXSelectedText}%%%
%%%{PBXSelection}%%%
EOF

除了bash脚本，XCode还支持Ruby，Python等多种语言的脚本，比如这个Ruby脚本

#!/usr/bin/env ruby -w

# Source: http://allancraig.net/blog/?p=315

properties = ''
synthesize = ''
release    = ''

STDIN.read.each do |line|
	line.gsub!(/\*/, '').strip!
	words = line.split(/\s+/)
	
	label = words.size > 2 ? words[1] : words[0]
	variable = words[-1]
	properties << "@property (nonatomic, retain) IBOutlet #{label} *#{variable}\n"
	synthesize << "@synthesize #{variable}\n"
	release << "[#{variable.chop} release];\n"
end

synthesize << release.chomp

`echo '#{synthesize.chomp}' | pbcopy`
print properties.chomp

该脚本的作用是帮助我们添加@property、@synthesize、还有dealloc方法中相应的release。使用方法是选中.h文件中的成员变量，比如我们选中UIButton *aButton;，复制到要添加@property的位置，再次选中，按快捷键执行脚本，@property就添加完成了，然后到相应的.m文件中，在要添加@synthesize的位置按⌘V粘贴，@synthesize也添加好了，同时复制过来的还有[aButton release];，选中这行，剪切粘贴到dealloc方法中，大功告成。使用这个脚本不仅可以快速添加@property @synthesize，同时也避免了变量名写错所造成的一些问题。

XCode技巧之自定义TextMacros

和这篇文章一样，以下基本都是从becoming productive in xcode中取得的

===Text Macros===

添加自己的TextMacros（XCode 3.2.5测试通过，XCode 4 未测试）

在~/Library/Application Support/Developer/Shared/Xcode/下面新建Specifications文件夹，建立与/Developer/Applications/Xcode.app/Contents/PlugIns/TextMacros.xctxtmacro/Contents/Resources文件夹下类似的*.xctxtmacro文件即可

例子

(
  {
    Identifier = objc.hello;
    BasedOn = objc;
    IsMenuItem = YES;
    OnlyAtBOL= YES;
    Name = "Hello";
    TextString = "Hello, XCode!";
    CompletionPrefix = "hello";
    IncludeContexts = ("xcode.lang.objc");
  },
  {
    Identifier = objc.property;
    BasedOn = objc;
    IsMenuItem = YES;
    OnlyAtBOL= YES;
    Name = "@property Definition";
    TextString = "@property (nonatomic, retain) IBOutlet <#type#> *<#variable#>;";
    CompletionPrefix = "prop";
    IncludeContexts = ("xcode.lang.objc.interface");
  },
  {
    Identifier = objc.rectmake;
    BasedOn = objc;
    IsMenuItem = YES;
    OnlyAtBOL= YES;
    Name = "RectMake";
    TextString = "CGRect aRect = \n\tCGRectMake(<#x#>, <#y#>, <#width#>, <#height#>);";
    CompletionPrefix = "cgrm";
    IncludeContexts = ("xcode.lang.objc.block");
  }
)

上面的代码添加了三个textmacro：

第一个仅仅是测试用，代码中输入hello即有自动补全提示，补全成Hello，Xcode！。

第二个效果是输入prop，然后 ⌃. 自动补全成@property (nonatomic, retain) IBOutlet <#type#> *<#variable#>;的形式，具体实验一下就知道了。

第三个类似，不多说了。

首先注意一下OnlyAtBOL这一行，在新版本的XCode中如果不加上这一行则textmacro无法生效。具体请看这一段的解释：

There is a bug on TextMacros in the latest versions of Xcode (I encourage you to send a bugreport to Apple as I did)

In fact, only TextMacros that have the value “YES” for the key “OnlyAtBOL” will work. If this key is not present (or set to NO), the macro will not respond to autocompletion.

Actually, the new “OnlyAtBOL” key means “Only at Beginning Of Line”, so the autocompletion for this macro will only work if it is triggered in the beggining of a line. But in fact, quite every macro I need everyday comply to this constraint (ifelse, nslog, nss, …) so this is acceptable.

If you want those macros (that does not work because of the lack of OnlyAtBOL set to YES) to work again, you need to add/override their specifications in your “Application Support” directory (in a custom TextMacro file that override them), until the Xcode team fixes that bug.

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 下命令行编辑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）

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)

标签：教程

动态调整UITableViewCell高度的实现方法

XCode技巧之UserScripts

XCode技巧之自定义TextMacros

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

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

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