41. Splash Screen开场屏在Android中的实现
很多网友可能发现近期Tencent推出的手机QQ Android版包含了一个开场屏Splash Screen载入效果，通常游戏或大型软件打开时可能需要一个释放解析资源的过程，需要一个前台的动画播放和后台的逻辑处理线程配合，当然对于简单的软件也可以加一个Splash Screen作为美化。在Android平台上如何实现呢?
  首先创建一个Activirty，在SetContentView时直接通过ImageView创建一个全屏的图片，Android123提示大家还要考虑好分辨率和当前设备一致，onCreate添加代码如下:
  new Handler().postDelayed(new Runnable(){   // 为了减少代码使用匿名Handler创建一个延时的调用
            public void run() { 
                Intent i = new Intent(SplashScreen.this, Main.class);    //通过Intent打开最终真正的主界面Main这个Activity
                SplashScreen.this.startActivity(i);    //启动Main界面
                SplashScreen.this.finish();    //关闭自己这个开场屏
            } 
        }, 5000);   //5秒，够用了吧
42. Android的Activity你知多少呢?
看到这个标题很多网友肯定回答，我知道Activity是Android上的窗口基类，了解Activity的生命周期比如onCreate onStop等，呵呵，按照这样说Android123还知道Activity的实现其实是从ApplicationContext，而ApplicationContext是从Context这个抽象类派生而来的，当然我们看到显示的是View或者ViewGroup，当然今天说的不是这些东西，而是很多网友来问的Android为什么不设计一个任务管理器，当然从Android 1.5开始ActivityManager类提供了restartPackage可以关闭一个程序，需要加上<uses-permission android:name="android.permission.RESTART_PACKAGES"/>这个权限，不过我们注意到，长按Home键可以看到以前程序的运行，同时可以快速的切换回来。这就是Android独有的程序生命周期管理机制 Activity历史栈。
  我们在一个普通的程序主窗口A中打开了一个窗口B，而窗口B打开了窗口C，但是按下Back键后结果出乎了预期，是的这就是Activity的history stack的原因，在数据结构中栈是FIFO的，阻止我们不愿意看的情况的发生则可以在打开新Activity时加上标记FLAG_ACTIVITY_NO_HISTORY，代码如下:
    Intent i= new Intent(this, cwj.class); 
    i.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);   //Android开发网提示大家相关的还有Intent.FLAG_ACTIVITY_CLEAR_TOP，都试试
    startActivity(i); 
  当然更多的程序Activity控制可以再androidmanifest.xml中定义。
43. JSONObject在Android上的应用
如果你过去开发过AJAX应用，相信对JSONObject不会陌生吧，作为基于JavaScript的数据交换格式，可以直接代替Xml，这里Android从1.0开始就完全支持JSONObject。在平时应用中直接引入import org.json.JSONObject;即可方便使用。当然同类的还有SOAP。
  在常规使用方便JSONObject对象可以实现类似Bundle或Parcel可以封装数据，代替一个XML的ITEM，但最大的优势是可以执行一些简单的方法，比如说getString、has、put、getBoolean、getInt等数据类型的存取操作。Android123提示大家对于常规的项目开发，今天本文不考虑Server端的布局，在Android平台上处理这些比较简单，主要是一些http的请求处理。可以直接引入import org.apache.http.xxx来实现web server层的数据交换，如果你没有专业的Server开发技术，可以通过简单的Web配合JSON方式快速实现自己的交互式应用。
44. Android高性能文件类MemoryFile
很多网友抱怨Android处理底层I/O性能不是很理想，如果不想使用NDK则可以通过MemoryFile类实现高性能的文件读写操作。MemoryFile顾名思义就是内存文件的意思，如果你过去从事过Win32开发，那么它的原理就是MapViewOfFile()，当然开发过Linux的网友可能很快就联想到了mmap()，是的该类就是他们的托管代码层封装，位于android.os.MemoryFile这个位置，从Android 1.0开始就被支持。
  MemoryFile适用于哪些地方呢?
  对于I/O需要频繁操作的，主要是和外部存储相关的I/O操作，MemoryFile通过将 NAND或SD卡上的文件，分段映射到内存中进行修改处理，这样就用高速的RAM代替了ROM或SD卡，性能自然提高不少，对于Android手机而言同时还减少了电量消耗。Android123提示网友该类实现的功能不是很多，直接从Object上继承，通过JNI的方式直接在C底层执行。
主要的构造方法 MemoryFile(String name, int length) ，这里第二个参数为文件大小，需要说明的是Android的MemoryFile和传统的mmap还有一点点区别，毕竟是手机，它内部的内存管理方式ashmem会从内核中回收资源。毕竟目前部分低端机型的RAM也比较吃紧。 
synchronized boolean  allowPurging(boolean allowPurging)  //允许ashmem清理内存，线程安全同步的方式。
void  close() //关闭，因为在Linux内部mmap占用一个句柄，不用时一定要释放了
InputStream  getInputStream()  返回读取的内容用Java层的InputStream保存
OutputStream  getOutputStream()  把一个OutputSream写入到MemoryFile中
boolean  isPurgingAllowed() //判断是否允许清理
int  length()  //返回内存映射文件大小
下面就是我们熟悉的，读写细节，主要是对字符数组的操作，这里大家要计算好每个文件类型的占用，同时考虑到效率对于自己分配的大小考虑粒度对齐。
int  readBytes(byte[] buffer, int srcOffset, int destOffset, int count)
void  writeBytes(byte[] buffer, int srcOffset, int destOffset, int count)  
  具体的实际应用，Android开发网将在下次和大家讲到。
45. TextUtils类-Android字符串处理类
对于字符串处理Android为我们提供了一个简单实用的TextUtils类，如果处理比较简单的内容不用去思考正则表达式不妨试试这个在android.text.TextUtils的类，主要的功能如下:
  是否为空字符 static boolean  isEmpty(CharSequence str) 
拆分字符串  public static String[] split (String text, String expression) ，Android开发网提示大家仔细看例子如下 String.split() returns [''] when the string to be split is empty. This returns []. This does not remove any empty strings from the result. For example split("a,", "," ) returns {"a", ""}.
拆分字符串使用正则 public static String[] split (String text, Pattern pattern)
  确定大小写是否有效在当前位置的文本TextUtils.getCapsMode(CharSequence cs, int off, int reqModes)
  使用HTML编码这个字符串  static String  TextUtils.htmlEncode(String s)  
46. InputSream输入流转String字符串，Android开发工具类
在Android平台上使用Java层处理I/O时主要使用流，这里Android开发网给大家一个方便的类，可以处理InputStream输入流转为String字符串，在效率上，我们使用了字符串拼接StringBuilder类减少内存碎片以及BefferedReader类实现一个缓存。
    private String Stream2String(InputStream is) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(is), 16*1024); //强制缓存大小为16KB，一般Java类默认为8KB
            StringBuilder sb = new StringBuilder();
            String line = null;
            try {
                while ((line = reader.readLine()) != null) {  //处理换行符
                    sb.append(line + "\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return sb.toString();
        }
    }
47. layout资源包含，android开发必读
有时候我们在一个Android程序中可能会复用布局文件，这时可以在一个xml文件中复用过去的布局文件，但是和常规的使用不同的是，需要加上类似包含头文件一样的include关键字，比如下面我们需要包含layout文件夹下的view.xml布局文件，需要<include layout="@layout/view" />  这样下，完整的如下，大家可以试一试。
<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    > 
<TextView   
    android:layout_width="wrap_content"  
    android:layout_height="wrap_content"  
    android:text="@string/cwj"
    />
<include layout="@layout/view" />
<include android:id="@+id/block" layout="@layout/item" />  
<TextView   
    android:layout_width="wrap_content"  
    android:layout_height="wrap_content"  
    android:text="@string/android123"
    /> 
</LinearLayout>
48.Android控件开发之ToggleButton原理
在Android平台上比较有特色的就是ToggleButton控件，虽然它的功能和CheckBox有些类似，但是他们的用处还是有一定的区别比如ToggleButton原本有图片装饰，通过ToggleButton可以很清楚的显示某些状态。它们均从Button为基类的CompoundButton中实现，其真假事件从Checkable来实现。
  public abstract class CompoundButton extends Button implements Checkable {
    private boolean mChecked; //状态是否选中
    private int mButtonResource;
    private boolean mBroadcasting;
    private Drawable mButtonDrawable; //按钮的图标
    private OnCheckedChangeListener mOnCheckedChangeListener; //选中状态改变监听
    private OnCheckedChangeListener mOnCheckedChangeWidgetListener;
    private static final int[] CHECKED_STATE_SET = {
        R.attr.state_checked
    };
    public CompoundButton(Context context) {
        this(context, null);
    }
    public CompoundButton(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
    public CompoundButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        TypedArray a =
                context.obtainStyledAttributes(
                        attrs, com.android.internal.R.styleable.CompoundButton, defStyle, 0);
        Drawable d = a.getDrawable(com.android.internal.R.styleable.CompoundButton_button);
        if (d != null) {
            setButtonDrawable(d);
        }
        boolean checked = a
                .getBoolean(com.android.internal.R.styleable.CompoundButton_checked, false);
        setChecked(checked);
        a.recycle(); //显式的GC
    }
    public void toggle() {
        setChecked(!mChecked);
    }
    @Override
    public boolean performClick() {
              toggle();
        return super.performClick();
    }
    public boolean isChecked() {
        return mChecked;
    }
    public void setChecked(boolean checked) {
        if (mChecked != checked) {
            mChecked = checked;
            refreshDrawableState(); //更新当前状态的按钮图标
            if (mBroadcasting) {
                return;
            }
            mBroadcasting = true;
            if (mOnCheckedChangeListener != null) {
                mOnCheckedChangeListener.onCheckedChanged(this, mChecked);
            }
            if (mOnCheckedChangeWidgetListener != null) {
                mOnCheckedChangeWidgetListener.onCheckedChanged(this, mChecked);
            }
            mBroadcasting = false;          
        }
    }
    public void setOnCheckedChangeListener(OnCheckedChangeListener listener) {
        mOnCheckedChangeListener = listener;
    }
    void setOnCheckedChangeWidgetListener(OnCheckedChangeListener listener) {
        mOnCheckedChangeWidgetListener = listener;
    }
    public static interface OnCheckedChangeListener {
        void onCheckedChanged(CompoundButton buttonView, boolean isChecked);
    }
     public void setButtonDrawable(int resid) {
        if (resid != 0 && resid == mButtonResource) {
            return;
        }
        mButtonResource = resid;
        Drawable d = null;
        if (mButtonResource != 0) {
            d = getResources().getDrawable(mButtonResource);
        }
        setButtonDrawable(d);
    }
    public void setButtonDrawable(Drawable d) {
        if (d != null) {
            if (mButtonDrawable != null) {
                mButtonDrawable.setCallback(null);
                unscheduleDrawable(mButtonDrawable);
            }
            d.setCallback(this);
            d.setState(getDrawableState());
            d.setVisible(getVisibility() == VISIBLE, false);
            mButtonDrawable = d;
            mButtonDrawable.setState(null);
            setMinHeight(mButtonDrawable.getIntrinsicHeight());
        }
        refreshDrawableState();
    }
    @Override
    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
        boolean populated = super.dispatchPopulateAccessibilityEvent(event);
        if (!populated) {
            int resourceId = 0;
            if (mChecked) {
                resourceId = R.string.accessibility_compound_button_selected;
            } else {
                resourceId = R.string.accessibility_compound_button_unselected;
            }
            String state = getResources().getString(resourceId);
            event.getText().add(state);
            event.setChecked(mChecked);
        }
        return populated;
    }
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        final Drawable buttonDrawable = mButtonDrawable;
        if (buttonDrawable != null) {
            final int verticalGravity = getGravity() & Gravity.VERTICAL_GRAVITY_MASK;
            final int height = buttonDrawable.getIntrinsicHeight();
            int y = 0;
            switch (verticalGravity) {
                case Gravity.BOTTOM:
                    y = getHeight() - height;
                    break;
                case Gravity.CENTER_VERTICAL:
                    y = (getHeight() - height) / 2;
                    break;
            }
            buttonDrawable.setBounds(0, y, buttonDrawable.getIntrinsicWidth(), y + height);
            buttonDrawable.draw(canvas);
        }
    }
    @Override
    protected int[] onCreateDrawableState(int extraSpace) {
        final int[] drawableState = super.onCreateDrawableState(extraSpace + 1);
        if (isChecked()) {
            mergeDrawableStates(drawableState, CHECKED_STATE_SET);
        }
        return drawableState;
    }
    @Override
    protected void drawableStateChanged() { //android123提示状态改变时需要更换按钮的图标
        super.drawableStateChanged();
        if (mButtonDrawable != null) {
            int[] myDrawableState = getDrawableState();
            mButtonDrawable.setState(myDrawableState);
            invalidate();
        }
    }
    @Override
    protected boolean verifyDrawable(Drawable who) {
        return super.verifyDrawable(who) || who == mButtonDrawable;
    }
    static class SavedState extends BaseSavedState {
        boolean checked;
             SavedState(Parcelable superState) {
            super(superState);
        }
        private SavedState(Parcel in) {
            super(in);
            checked = (Boolean)in.readValue(null);
        }
        @Override
        public void writeToParcel(Parcel out, int flags) {
            super.writeToParcel(out, flags);
            out.writeValue(checked);
        }
        @Override
        public String toString() {
            return "CompoundButton.SavedState{"
                    + Integer.toHexString(System.identityHashCode(this))
                    + " checked=" + checked + "}";
        }
        public static final Parcelable.Creator<SavedState> CREATOR
                = new Parcelable.Creator<SavedState>() {
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in);
            }
            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };
    }
    @Override
    public Parcelable onSaveInstanceState() {
        // Force our ancestor class to save its state
        setFreezesText(true);
        Parcelable superState = super.onSaveInstanceState();
        SavedState ss = new SavedState(superState);
        ss.checked = isChecked();
        return ss;
    }
    @Override
    public void onRestoreInstanceState(Parcelable state) {
        SavedState ss = (SavedState) state;
        super.onRestoreInstanceState(ss.getSuperState());
        setChecked(ss.checked);
        requestLayout();
    }
}
从上面来看我们知道CompuundButton的实现相对繁琐了些，主要是考虑状态是否已经选中等情况的消息通知，Android开发网提醒大家而ToggleButton相对CompuundButton增加的给用户而言主要是开关的文字显示。
public class ToggleButton extends CompoundButton {
    private CharSequence mTextOn;
    private CharSequence mTextOff;
    private Drawable mIndicatorDrawable;
    private static final int NO_ALPHA = 0xFF;
    private float mDisabledAlpha;
    public ToggleButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        TypedArray a =
            context.obtainStyledAttributes(
                    attrs, com.android.internal.R.styleable.ToggleButton, defStyle, 0);
        mTextOn = a.getText(com.android.internal.R.styleable.ToggleButton_textOn);
        mTextOff = a.getText(com.android.internal.R.styleable.ToggleButton_textOff);
        mDisabledAlpha = a.getFloat(com.android.internal.R.styleable.ToggleButton_disabledAlpha, 0.5f);
        syncTextState();
        a.recycle();
    }
    public ToggleButton(Context context, AttributeSet attrs) {
        this(context, attrs, com.android.internal.R.attr.buttonStyleToggle);
    }
    public ToggleButton(Context context) {
        this(context, null);
    }
    @Override
    public void setChecked(boolean checked) {
        super.setChecked(checked);
        syncTextState();
    }
    private void syncTextState() {
        boolean checked = isChecked();
        if (checked && mTextOn != null) {
            setText(mTextOn);
        } else if (!checked && mTextOff != null) {
            setText(mTextOff);
        }
    }
    public CharSequence getTextOn() {
        return mTextOn;
    }
    public void setTextOn(CharSequence textOn) {
        mTextOn = textOn;
    }
    public CharSequence getTextOff() {
        return mTextOff;
    }
    protected void onFinishInflate() {
        super.onFinishInflate();
        updateReferenceToIndicatorDrawable(getBackground());
    }
    @Override
    public void setBackgroundDrawable(Drawable d) {
        super.setBackgroundDrawable(d);
        updateReferenceToIndicatorDrawable(d);
    }
    private void updateReferenceToIndicatorDrawable(Drawable backgroundDrawable) {
        if (backgroundDrawable instanceof LayerDrawable) {
            LayerDrawable layerDrawable = (LayerDrawable) backgroundDrawable;
            mIndicatorDrawable =
                    layerDrawable.findDrawableByLayerId(com.android.internal.R.id.toggle);
        }
    }
    @Override
    protected void drawableStateChanged() {
        super.drawableStateChanged();
        if (mIndicatorDrawable != null) {
            mIndicatorDrawable.setAlpha(isEnabled() ? NO_ALPHA : (int) (NO_ALPHA * mDisabledAlpha));
        }
    }
}
49. AsyncTask实例代码演示Android异步任务
上次我们讲到了Android提供了一个较线程更简单的处理多任务的方法AsyncTask异步任务类，相对于线程来说AsyncTask对于简单的任务处理更安全，其内部的实现方法使用了Android的Handler机制，对于常见的文件下载可以使用AsyncTask类来处理，在Browser浏览器中就是用了该类下载Web服务器URL的Favicon图标。
  首先Android123以简单的下载例子演示该类的大致结构，如下
private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
    protected Long doInBackground(URL... urls) {
        int count = urls.length;
        long totalSize = 0;
        for (int i = 0; i < count; i++) {
            totalSize += Downloader.downloadFile(urls[i]);
            publishProgress((int) ((i / (float) count)100));
        }
        return totalSize;
    }
    protected void onProgressUpdate(Integer... progress) {
        setProgressPercent(progress[0]);
    }
    protected void onPostExecute(Long result) {
        showDialog("Downloaded " + result + " bytes");
    }
}
  最终我们执行 DownloadFilesTask().execute(url1, url2, url3); 即可。
  在Android浏览器中下载Favicon图标的实现如下:
class DownloadTouchIcon extends AsyncTask<String, Void, Bitmap> {
    private final ContentResolver mContentResolver;
    private final Cursor mCursor;
    private final String mOriginalUrl;
    private final String mUrl;
    private final String mUserAgent;
    /* package */ BrowserActivity mActivity;
    public DownloadTouchIcon(BrowserActivity activity, ContentResolver cr,
            Cursor c, WebView view) { //构造方法
        mActivity = activity;
        mContentResolver = cr;
        mCursor = c;
        mOriginalUrl = view.getOriginalUrl();
        mUrl = view.getUrl();
        mUserAgent = view.getSettings().getUserAgentString();
    }
    public DownloadTouchIcon(ContentResolver cr, Cursor c, String url) { //实现本类的构造
        mActivity = null;
        mContentResolver = cr;
        mCursor = c;
        mOriginalUrl = null;
        mUrl = url;
        mUserAgent = null;
    }
    @Override
    public Bitmap doInBackground(String... values) {   //返回Bitmap类型
        String url = values[0];
        AndroidHttpClient client = AndroidHttpClient.newInstance(mUserAgent);
        HttpGet request = new HttpGet(url);
       HttpClientParams.setRedirecting(client.getParams(), true); //处理302等重定向问题
        try {
            HttpResponse response = client.execute(request);
            if (response.getStatusLine().getStatusCode() == 200) { //如果OK
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    InputStream content = entity.getContent(); //将图标保存到InputStream中，因为是二进制内容
                    if (content != null) {
                        Bitmap icon = BitmapFactory.decodeStream( //从流中取出Bitmap，这里使用了BitmapFactory类的静态方法decodeStream
                                content, null, null);
                        return icon;
                    }
                }
            }
        } catch (IllegalArgumentException ex) {
            request.abort();
        } catch (IOException ex) {
            request.abort();
        } finally {
            client.close();
        }
        return null;
    }
    @Override
    protected void onCancelled() {
        if (mCursor != null) {
            mCursor.close();
        }
    }
    @Override
    public void onPostExecute(Bitmap icon) {
          if (mActivity != null) {
             mActivity.mTouchIconLoader = null;
        }
        if (icon == null || mCursor == null || isCancelled()) {
            return;
        }
    最终图标要保存到浏览器的内部数据库中，系统程序均保存为SQLite格式，Browser也不例外，因为图片是二进制的所以使用字节数组存储数据库的BLOB类型
        final ByteArrayOutputStream os = new ByteArrayOutputStream();
        icon.compress(Bitmap.CompressFormat.PNG, 100, os); //将Bitmap压缩成PNG编码，质量为100%存储
        ContentValues values = new ContentValues(); //构造SQLite的Content对象，这里也可以使用raw sql代替
        values.put(Browser.BookmarkColumns.TOUCH_ICON,os.toByteArray()); //写入数据库的Browser.BookmarkColumns.TOUCH_ICON字段
        if (mCursor.moveToFirst()) {
            do {
                mContentResolver.update(ContentUris.withAppendedId(Browser.BOOKMARKS_URI, mCursor.getInt(0)),values, null, null);
            } while (mCursor.moveToNext());
        }
        mCursor.close();
    }
}
  本次Android开发网通过两个AsyncTask类演示了多种类型的任务构造，这里大家注意返回类型，本节演示了Android平台上Content Provider、AsyncTask、Bitmap、HTTP以及Stream的相关操作，大家如何想很快提高开发水平其实只要理解Google如何去实现Android系统常规构架就可以轻松入门谷歌移动平台。
50. Android自定义View实例AnalogClock源码
针对Android底层View的直接构造很多网友没有实战经验，本次Android开发网结合目前平台开源代码一起通过AnalogClock类来理解View的直接继承。AnalogClock就是Home Screen上的那个带有两根指针的表盘类。它的实现我们直接从开源代码可以了解到:
  public class AnalogClock extends View {
    private Time mCalendar;
    private Drawable mHourHand; //时针
    private Drawable mMinuteHand; //分针
    private Drawable mDial; //表盘背景
    private int mDialWidth; //表盘宽度
    private int mDialHeight; //表盘高度
    private boolean mAttached; //附着状态
    private final Handler mHandler = new Handler(); //定一个Handler类实现更新时间
    private float mMinutes;
    private float mHour;
    private boolean mChanged; //时间是否改变
    public AnalogClock(Context context) {
        this(context, null);
    }
    public AnalogClock(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
    public AnalogClock(Context context, AttributeSet attrs,
                       int defStyle) {
        super(context, attrs, defStyle);
        Resources r = mContext.getResources();
        TypedArray a =
                context.obtainStyledAttributes(
                        attrs, com.android.internal.R.styleable.AnalogClock, defStyle, 0);
        mDial = a.getDrawable(com.android.internal.R.styleable.AnalogClock_dial); //加载表盘资源
        if (mDial == null) {
            mDial = r.getDrawable(com.android.internal.R.drawable.clock_dial);
        }
        mHourHand = a.getDrawable(com.android.internal.R.styleable.AnalogClock_hand_hour); //加载时针图片资源
        if (mHourHand == null) {
            mHourHand = r.getDrawable(com.android.internal.R.drawable.clock_hand_hour);
        }
        mMinuteHand = a.getDrawable(com.android.internal.R.styleable.AnalogClock_hand_minute); //加载分针图片
        if (mMinuteHand == null) {
            mMinuteHand = r.getDrawable(com.android.internal.R.drawable.clock_hand_minute);
        }
        mCalendar = new Time(); //获取当前系统时间
        mDialWidth = mDial.getIntrinsicWidth(); //获取表盘图片的宽度
        mDialHeight = mDial.getIntrinsicHeight(); //高度，同上
    }
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        if (!mAttached) {
            mAttached = true;
            IntentFilter filter = new IntentFilter(); //注册一个消息过滤器，获取时间改变、时区改变的action
            filter.addAction(Intent.ACTION_TIME_TICK);
            filter.addAction(Intent.ACTION_TIME_CHANGED);
            filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
            getContext().registerReceiver(mIntentReceiver, filter, null, mHandler);
        }
          mCalendar = new Time();
        onTimeChanged();
    }
    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
        if (mAttached) {
            getContext().unregisterReceiver(mIntentReceiver); //反注册消息过滤器
            mAttached = false;
        }
    }
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize =  MeasureSpec.getSize(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize =  MeasureSpec.getSize(heightMeasureSpec);
        float hScale = 1.0f;
        float vScale = 1.0f;
        if (widthMode != MeasureSpec.UNSPECIFIED && widthSize < mDialWidth) {
            hScale = (float) widthSize / (float) mDialWidth;
        }
        if (heightMode != MeasureSpec.UNSPECIFIED && heightSize < mDialHeight) {
            vScale = (float )heightSize / (float) mDialHeight;
        }
        float scale = Math.min(hScale, vScale);
        setMeasuredDimension(resolveSize((int) (mDialWidth * scale), widthMeasureSpec),
                resolveSize((int) (mDialHeight * scale), heightMeasureSpec));
    }
    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mChanged = true;
    }
    主要的绘图重写View的onDraw方法，我们可以看到通过canvas实例直接屏幕
@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        boolean changed = mChanged;
        if (changed) {
            mChanged = false;
        }
        int availableWidth = mRight - mLeft;
        int availableHeight = mBottom - mTop;
        int x = availableWidth / 2;
        int y = availableHeight / 2;
        final Drawable dial = mDial;
        int w = dial.getIntrinsicWidth();
        int h = dial.getIntrinsicHeight();
        boolean scaled = false;
        if (availableWidth < w || availableHeight < h) {
            scaled = true;
            float scale = Math.min((float) availableWidth / (float) w,
                                   (float) availableHeight / (float) h);
            canvas.save();
            canvas.scale(scale, scale, x, y);
        }
        if (changed) {
            dial.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
        }
        dial.draw(canvas);
        canvas.save();
        canvas.rotate(mHour / 12.0f * 360.0f, x, y); //计算时针旋转的角度，android123提示就是那个时针图片的旋转角度，直接反应的就是表盘上那个针的时间
        final Drawable hourHand = mHourHand;
        if (changed) {
            w = hourHand.getIntrinsicWidth();
            h = hourHand.getIntrinsicHeight();
            hourHand.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
        }
        hourHand.draw(canvas);
        canvas.restore();
        canvas.save();
        canvas.rotate(mMinutes / 60.0f * 360.0f, x, y); //同理，分针旋转的角度
        final Drawable minuteHand = mMinuteHand;
        if (changed) {
            w = minuteHand.getIntrinsicWidth();
            h = minuteHand.getIntrinsicHeight();
            minuteHand.setBounds(x - (w / 2), y - (h / 2), x + (w / 2), y + (h / 2));
        }
        minuteHand.draw(canvas);
        canvas.restore();
        if (scaled) {
            canvas.restore();
        }
    }
    private void onTimeChanged() {  //获取时间改变，计算当前的时分秒
        mCalendar.setToNow();
        int hour = mCalendar.hour;
        int minute = mCalendar.minute;
        int second = mCalendar.second;
        mMinutes = minute + second / 60.0f;
        mHour = hour + mMinutes / 60.0f;
        mChanged = true;
    }
    private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { //监听获取时间改变action
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(Intent.ACTION_TIMEZONE_CHANGED)) {
                String tz = intent.getStringExtra("time-zone");
                mCalendar = new Time(TimeZone.getTimeZone(tz).getID());
            }
            onTimeChanged(); //获取新的时间
            invalidate(); //刷新屏幕，强制类调用onDraw方法实现分针时针的走动
        }
    }; 
  看了本例根据，Android开发很简单吧，感兴趣的网友可以为本程序加入一个秒针，不过Android123提醒网友的是可能对于电池，以及系统运行效率产生一定的影响，不过作为练习大家可以试一试。
51. ArrayList LinkedList Set HashMap介绍
  在Android开发中我们经常需要对数据进行分类和操作，对于轻量级的数据存储我们可能不需要动用SQLite或效率以及类库不完善的XML，由于SharedPreferences不具备数据枚举方法，如果仅仅是一个String或Int数组可以通过一个标记分割设计外，我们还是主要来看看Android或者说Java提供的基础数据类型辅助类ArrayList LinkedList Set HashMap的介绍，如果你熟悉C++的STL或Boost库可以略过本文。
   在Java中提供了Collection和Map接口。其中List和Set继承了Collection接口；同时用Vector、ArrayList、LinkedList三个类实现List接口，HashSet、TreeSet实现Set接口。直接有HashTable、HashMap、TreeMap实现Map接口。
    Vector基于Array的List，性能也就不可能超越Array，并且Vector是“sychronized”的，这个也是Vector和ArrayList的唯一的区别。
    ArrayList：同Vector一样是一个基于Array的，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些。Android123提示大家适用于顺序性的查找
    LinkedList：不同于前面两种List，它不是基于Array的，作为链表数据结构方式，所以不受Array性能的限制。当对LinkedList做添加，删除动作的时候只要更改nextNode的相关信息就可以实现了所以它适合于进行频繁进行插入和删除操作。这就是LinkedList的优势，当然对于元素的位置获取等方面就逊色很多。
    List：
        1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]；
        2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]；
        3. 所有的List中可以有null元素，例如[ tom,null,1 ]；
        4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。
虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。
     HashSet：HashSet的存储方式是把HashMap中的Key作为Set的对应存储项，HashMap的key是不能有重复的。HashSet能快速定位一个元素，但是放到HashSet中的对象需要实现hashCode()方法0。
    TreeSet：将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的。TreeSet不同于HashSet的根本是TreeSet是有序的。它是通过SortedMap来实现的。
    Set总结： 1. Set实现的基础是Map（HashMap）； 2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象，不能包含两个元素e1、e2（e1.equals（e2））。
    Map是一种把键对象和值对象进行关联的容器，Map有两种比较常用的实现： HashTable、HashMap和TreeMap。
    HashMap也用到了哈希码的算法，以便快速查找一个键，
    TreeMap则是对键按序存放，因此它有一些扩展的方法，比如firstKey(),lastKey()等。
    HashMap和Hashtable的区别。 HashMap允许空（null）键（key）或值（value），由于非线程安全，效率上可能高于Hashtable。 Hashtable不允许空（null）键（key）或值（value）。
   有关更多实用的Android开发技巧我们将在后面的文章中着重介绍。
52. ConditionVariable Android线程同步
ConditionVariable类位于android.os.ConditionVariable，它可以帮助Android线程同步。在SDK上的介绍ConditionVariable不同于标准Java位于java.lang.Object wait() 和 notify() ，这个类可以等待自己，这就意味着 open(), close() 和 block() 可能会假死 ，如果使用ConditionVariable类的open()在调用 block() 之前， block() 将不会阻塞，相反将会返回立即。
   该类一共有4个方法
   boolean  block(long timeout)
  阻止当前线程知道条件是open，或直到超时，这里参数long timeout为超时设置，Android123提示大家如果你们从事过Win32开发，这个方法类似DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds); 函数。
  void  block()
  阻止当前线程知道条件 open ，是上面的无超时等待重载版本。
  void  close()
重置条件为 close状态。
void  open()
Open条件，释放所有线程的阻塞.
  ConditionVariable在创建时还有一种构造方法是 public ConditionVariable (boolean state) ，如果为true，默认时为opened，如果为false则是closed. ，默认public ConditionVariable () 为close().
53.Android开发之Eclipse调试技巧
使用Google提供的ADT插件可以在Eclipse上很轻松的调试Android程序，我们切换到DDMS标签，选择“Devices”标签，我们可以看到会出现类似下面的Debug Process(调试进程)、Update Threads(更新线程)、Update Heap(更新堆)、Cause GC(引起垃圾回收)、Stop Process(停止进程)、Screen Capture(屏幕截图)、Reset adb(重启Android Debug Bridge)
  这里我们就可以很好的观察Android程序运行时的各种状态，比如进程信息、线程分析、堆内存的占用，结束一个进程，当然这些操作都是在DDMS框架下进行的，日程开发的程序是无法执行调用的。如果遇到adb调试桥运行不稳定时可以选择reset adb来重新启动adb.exe进程,整个界面如图:

Android性能与调试很重要

  用于手持的移动设备，Android软件性能上需要多加考虑。首先Java VM在资源占用上开销是很大的，很多垃圾GC处理机制直接影响到内存释放和整个平台运行的流畅度。
  1.节省电量
  手机软件必须考虑的问题是省电，如果需要大型处理尽量由服务器处理，直接把结果返回到手持设备上。多线程也是一种奢侈的使用，但是I/O存储必需这样才能保证流畅度，线程的阻塞将会降低用户体验，但是线程间切换调度的开销一直是重点。Android在DDMS中加入了Thread查看。
  2.内存占用
  在Eclipse+ADT插件的开发方式中，我们在DDMS中可以看到Heap堆内存的显示,Android开发网提示的是Java内存分配方式的问题，尽量产生少的对象，比如字符串操作如果连加比较多，可以使用StringBuilder代替String类。在游戏开发中经常用到的图片可以通过切片的方式从一个大的png图片上截取，或者放在gif文件作为逐帧保存，这样可以共用文件头减小体积。
  3.调试工具
  Android调试工具主要是模拟器中的Dev Tools和DDMS中的Logcat查看。当然模拟器自带的Dev Tools在功能上还是很详细的，可以显示CPU占用率，内存使用量，在单元测试时需要多加分析。
Android开发工具Dev Tools介绍
ndroid提供了很多开发调试工具除了ADB、TraceView、Logcat外，今天这个名为Dev Tools的Android开发调试工具隐藏在Android模拟器中，为我们提供了强大的调试支持。我们在功能表中找到Dev Tools，运行后可以看到有很多条目，比如Development Settings，用来开发设置，进入后我们看到了比如Show CPU Usage这样的实用功能显示CPU占用率，帮助Android开发人员分析当前软件性能情况，今天就分析下Development Settings中的选项:
Wait for debugger 等待调试器
Enable ADB 启用ADB(android调试桥)
Show running processs (显示运行中的进程)
Show screen updates (显示屏幕更新)
  下面是一些常规的调试选项，Android开发网友情提示开启这些选项后可能会影响运行效率，这些探测选项也是CPU敏感的。
Immediately destroy activites (立即销毁activities)
Show CPU usage (显示CPU占用率)
Show background (显示北京)
Show Sleep state on LED (在休眠状态下LED开启)
Keep screen on while plugged in (保持屏幕开启当插入后)
Show GTalk service connection status (显示GTalk服务连接状态)