从源码上剖析Android View绘制Drawable的原理

一、引言

对于Drawable，相比每个Android 开发者都无比熟悉，在开发过程中我们经常setBackground设置背景，那么对于Drawable你了解多少呢？对于View是怎样把Drawable绘制出来又了解多少呢？对View根据不同状态绘制不同的背景又了解多少呢？也就是我们经常使用的selector，今天我们从源码上来深度剖析这些原理，从本质上卸下Drawable的神秘面纱。

二、背景介绍

在源码路径：frameworks/base/graphics/java/android/graphics/drawable/Drawable.java
进入Drawable.java里面去看源码，你会看到这样一段描述文字：

A Drawable is a general abstraction for "something that can be drawn."  Most
 1. often you will deal with Drawable as the type of resource retrieved for
 2. drawing things to the screen; the Drawable class provides a generic API for
 3. dealing with an underlying visual resource that may take a variety of forms.
 4. Unlike a {@link android.view.View}, a Drawable does not have any facility to
 5. receive events or otherwise interact with the user.

也就是说Drawable是Android开发中的通用可绘制对象，View类默认针对Drawable进行一些必要的绘制，如背景。

三、Drawable的核心分析

1、先来介绍背景选择器selector
对Android开发有经验的同学，对 节点的使用一定很熟悉，该节点的作用就是定义一组状态资源图片，使其能够在不同的状态下更换某个View的背景图片。比如demo_selector.xml

<?xml version="1.0" encoding="utf-8" ?>   
<selector xmlns:android="http://schemas.android.com/apk/res/android"> 
  <!-- 触摸时并且当前窗口处于交互状态 -->  
  <item android:state_pressed="true" android:state_window_focused="true" android:drawable= "@drawable/pic1" />
  <!--  触摸时并且没有获得焦点状态 -->  
  <item android:state_pressed="true" android:state_focused="false" android:drawable="@drawable/pic2" />  
  <!--选中时的图片背景-->  
  <item android:state_selected="true" android:drawable="@drawable/pic3" />   
  <!--获得焦点时的图片背景-->  
  <item android:state_focused="true" android:drawable="@drawable/pic4" />  
  <!-- 窗口没有处于交互时的背景图片 -->  
  <item android:drawable="@drawable/pic5" /> 
</selector>

其实这个xml文件会被Android框架解析成StateListDrawable类对象。通常我们在XML文件中设置View的background如下：

android:background="@drawable/drawable_bg"/*设置其他Drawable背景*/
android:background="#ff124a54"/*设置颜色背景*/

对于background我们应该明确一下几点知识：android:background属性值在实际操作中都会实例化为Drawable，常用的属性值与Drawable对象关系如下：

• “#ffffffff”=>ColorDrawable
• @drawable/shape_bg”=>GradientDrawable（假设shape_bg.xml文件为顶层为shape标签）
• “@drawable/bmp_bg”=>BitmapDrawable（假设bmp_bg为.png/.jpg/.bmp文件）
• “@drawable/9patch_bg”=>NinePatchDrawable（假设9patch_bg为.9.png文件）

2、接下来分析Drawable的ConstantState

在用代码生成Drawable的时候，相信你会经常看看ConstantState的身影，那么ConstantState到底是什么鬼呢？下面我们来揭开它的神秘面纱。
如果把Drawable比作一个绘制容器，那么ConstantState就是容器中真正的内容，Drawable的源码如下：

 /**
     * This abstract class is used by {@link Drawable}s to store shared constant state and data
     * between Drawables. {@link BitmapDrawable}s created from the same resource will for instance
     * share a unique bitmap stored in their ConstantState.
     *
     * <p>
     * {@link #newDrawable(Resources)} can be used as a factory to create new Drawable instances
     * from this ConstantState.
     * </p>
     *
     * Use {@link Drawable#getConstantState()} to retrieve the ConstantState of a Drawable. Calling
     * {@link Drawable#mutate()} on a Drawable should typically create a new ConstantState for that
     * Drawable.
     */
    public static abstract class ConstantState {
        /**
         * Create a new drawable without supplying resources the caller
         * is running in.  Note that using this means the density-dependent
         * drawables (like bitmaps) will not be able to update their target
         * density correctly. One should use {@link #newDrawable(Resources)}
         * instead to provide a resource.
         */
        public abstract Drawable newDrawable();

        /**
         * Create a new Drawable instance from its constant state.  This
         * must be implemented for drawables that change based on the target
         * density of their caller (that is depending on whether it is
         * in compatibility mode).
         */
        public Drawable newDrawable(Resources res) {
            return newDrawable();
        }

        /**
         * Create a new Drawable instance from its constant state. This must be
         * implemented for drawables that can have a theme applied.
         */
        public Drawable newDrawable(Resources res, Theme theme) {
            return newDrawable(null);
        }

        /**
         * Return a bit mask of configuration changes that will impact
         * this drawable (and thus require completely reloading it).
         */
        public abstract int getChangingConfigurations();

        /**
         * @return Total pixel count
         * @hide
         */
        public int addAtlasableBitmaps(Collection<Bitmap> atlasList) {
            return 0;
        }

        /** @hide */
        protected final boolean isAtlasable(Bitmap bitmap) {
            return bitmap != null && bitmap.getConfig() == Bitmap.Config.ARGB_8888;
        }

        /**
         * Return whether this constant state can have a theme applied.
         */
        public boolean canApplyTheme() {
            return false;
        }
    }

    /**
     * Return a {@link ConstantState} instance that holds the shared state of this Drawable.
     *
     * @return The ConstantState associated to that Drawable.
     * @see ConstantState
     * @see Drawable#mutate()
     */
    public ConstantState getConstantState() {
        return null;
    }

可以看出，ConstantState其实是Drawable中的静态抽象类，并且getConstantState()方法默认返回null，这我们可以推测ConstantState类和getConstantState()方法会被具体的Drawable实现类继承和重写。这样不难想象，由于不同Drawbale如BitmapDrawable、GradientDrawable这些自身存储的绘制内容数据原则上是不一样的，这就意味着Drawable为了易于扩展，ConstantState对象应该会存储属性可变的数据。
参考StateListDrawable的源码，确实是有DrawableContainer继承ConstantState的身影。

    static class StateListState extends DrawableContainerState {
        int[] mThemeAttrs;
        int[][] mStateSets;

        StateListState(StateListState orig, StateListDrawable owner, Resources res) {
            super(orig, owner, res);

            if (orig != null) {
                // Perform a shallow copy and rely on mutate() to deep-copy.
                mThemeAttrs = orig.mThemeAttrs;
                mStateSets = orig.mStateSets;
            } else {
                mThemeAttrs = null;
                mStateSets = new int[getCapacity()][];
            }
        }

        void mutate() {
            mThemeAttrs = mThemeAttrs != null ? mThemeAttrs.clone() : null;

            final int[][] stateSets = new int[mStateSets.length][];
            for (int i = mStateSets.length - 1; i >= 0; i--) {
                stateSets[i] = mStateSets[i] != null ? mStateSets[i].clone() : null;
            }
            mStateSets = stateSets;
        }

        int addStateSet(int[] stateSet, Drawable drawable) {
            final int pos = addChild(drawable);
            mStateSets[pos] = stateSet;
            return pos;
        }

        int indexOfStateSet(int[] stateSet) {
            final int[][] stateSets = mStateSets;
            final int N = getChildCount();
            for (int i = 0; i < N; i++) {
                if (StateSet.stateSetMatches(stateSets[i], stateSet)) {
                    return i;
                }
            }
            return -1;
        }

        @Override
        public Drawable newDrawable() {
            return new StateListDrawable(this, null);
        }

        @Override
        public Drawable newDrawable(Resources res) {
            return new StateListDrawable(this, res);
        }

        @Override
        public boolean canApplyTheme() {
            return mThemeAttrs != null || super.canApplyTheme();
        }

        @Override
        public void growArray(int oldSize, int newSize) {
            super.growArray(oldSize, newSize);
            final int[][] newStateSets = new int[newSize][];
            System.arraycopy(mStateSets, 0, newStateSets, 0, oldSize);
            mStateSets = newStateSets;
        }
    }

那么Drawable跟ConstantState之间有什么关系呢？
大家可以看看国外这篇文章http://www.curious-creature.com/2009/05/02/drawable-mutations/
其实两者之间的关系如下图所示：

由同一个Resource实例化生成的多个Drawable公用一个ConstanteState，这是出于对内存节省策略的考虑。那么当我们需要修改多个Drawable中的其中一个的属性时，就会出现修改后的Drawable影响到了其他Drawable的情况，针对这种情况，我们的想法自然是复制一份ConstantState从而避免相互间的干扰。

从根源上复制Drawable的方法可以使用：

/*假设dr为原有Drawable*/
Drawable newDr = dr.getConstantState().newDrawable();
/*或者*/
Drawable newDr = dr.getConstantState().newDrawable().mutate();

例如，我在Switch.java中有这样子的定义：

 if (mTrackDrawable != null) {
            mTrackDrawable.setCallback(this);
            if (mTrackDrawable.getConstantState() != null) {
                mTrackOnDrawable = mTrackDrawable.getConstantState().newDrawable().mutate();
                mTrackOnDrawable.setState(new int[]{android.R.attr.state_checked});
            }
            if (mTrackDrawable.getConstantState() != null) {
                mTrackOffDrawable = mTrackDrawable.getConstantState().newDrawable().mutate();
                mTrackOffDrawable.setState(new int[]{-android.R.attr.state_checked});
            }
        }

3、StateListDrawable类简介
类功能说明：该类定义了不同状态值下与之对应的图片资源，即我们可以利用该类保存多种状态值，多种图片资源。
常用方法为：

   public void addState (int[] stateSet, Drawable drawable)
       功能： 给特定的状态集合设置drawable图片资源

还记得我在前面介绍Selector的时候有说过XML最终会转换成StateListDrawable类，所以我们还是以demo_selector.xml来分析。

//初始化一个空对象
StateListDrawable stalistDrawable = new StateListDrawable();
//获取对应的属性值 Android框架自带的属性 attr
int pressed = android.R.attr.state_pressed;
int window_focused = android.R.attr.state_window_focused;
int focused = android.R.attr.state_focused;
int selected = android.R.attr.state_selected;

stalistDrawable.addState(new int []{pressed , window_focused}, getResources().getDrawable(R.drawable.pic1));
stalistDrawable.addState(new int []{pressed , -focused}, getResources().getDrawable(R.drawable.pic2);
stalistDrawable.addState(new int []{selected }, getResources().getDrawable(R.drawable.pic3);
stalistDrawable.addState(new int []{focused }, getResources().getDrawable(R.drawable.pic4);
//没有任何状态时显示的图片，我们给它设置我空集合
stalistDrawable.addState(new int []{}, getResources().getDrawable(R.drawable.pic5);

上面的“-”负号表示对应的属性值为false
当我们为某个View使用其作为背景色时，会根据状态进行背景图的转换。

     public boolean isStateful ()
     功能： 表明该状态改变了，对应的drawable图片是否会改变。
     注：在StateListDrawable类中，该方法返回为true，显然状态改变后，我们的图片会跟着改变

说到状态那么不得不说在Android中View的各种状态， 一般来说，Android框架为View定义了四种不同的状态，这些状态值的改变会引发View相关操作，例如：更换背景图片、是否触发点击事件等；我们来看下图：（注明：图片表格是借鉴网上资源）

注意：selected不同于focus状态，通常在AdapterView类群下例如ListView或者GridView会使某个View处于
selected状态，并且获得该状态的View处于高亮状态。而一个窗口只能有一个视图获得焦点(focus)，而一个窗口可以有多个视图处于”selected”状态中。
总结：focused状态一般是由按键操作引起的；
pressed状态是由触摸消息引起的；
selected则完全是由应用程序主动调用setSelected()进行控制。

4、View如何根据状态值的改变去绘制/显示对应的背景图？
当View任何状态值发生改变时，都会调用refreshDrawableList()方法去更新对应的背景Drawable对象。
源码路径：frameworks\base\core\java\android\view\View.java

    /**
     * Call this to force a view to update its drawable state. This will cause
     * drawableStateChanged to be called on this view. Views that are interested
     * in the new state should call getDrawableState.
     *
     * @see #drawableStateChanged
     * @see #getDrawableState
     */
    public void refreshDrawableState() {
        mPrivateFlags |= PFLAG_DRAWABLE_STATE_DIRTY;
        //改变drawable状态
        drawableStateChanged();
        ViewParent parent = mParent;
        if (parent != null) {
        //如果该View之上仍有父View，则一直递归通知
            parent.childDrawableStateChanged(this);
        }
    }

该方法主要功能是根据当前的状态值去更换对应的背景Drawable对象。重点看看drawableStateChanged()

/**
     * This function is called whenever the state of the view changes in such
     * a way that it impacts the state of drawables being shown.
     * <p>
     * If the View has a StateListAnimator, it will also be called to run necessary state
     * change animations.
     * <p>
     * Be sure to call through to the superclass when overriding this function.
     *
     * @see Drawable#setState(int[])
     */
    @CallSuper
    protected void drawableStateChanged() {
    //获取当前Drawable状态（pressed），刷新mBackground的状态
        final int[] state = getDrawableState();

        final Drawable bg = mBackground;
        if (bg != null && bg.isStateful()) {
            bg.setState(state);
        }

        final Drawable fg = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
        if (fg != null && fg.isStateful()) {
            fg.setState(state);
        }

        if (mScrollCache != null) {
            final Drawable scrollBar = mScrollCache.scrollBar;
            if (scrollBar != null && scrollBar.isStateful()) {
                scrollBar.setState(state);
            }
        }

        if (mStateListAnimator != null) {
            mStateListAnimator.setState(state);
        }
    }

该方法获得当前的状态属性— 整型集合 ； 调用Drawable类的setState方法去获取资源，最后进去看看setState()方法的具体实现：

 public boolean setState(final int[] stateSet) {
        if (!Arrays.equals(mStateSet, stateSet)) {
            mStateSet = stateSet;
            return onStateChange(stateSet);
        }
        return false;
    }

判断状态值是否发生了变化，如果发生了变化，就调用onStateChange()方法进一步处理。

 @Override
    protected boolean onStateChange(int[] stateSet) {
        final boolean changed = super.onStateChange(stateSet);

        int idx = mStateListState.indexOfStateSet(stateSet);
        if (DEBUG) android.util.Log.i(TAG, "onStateChange " + this + " states "
                + Arrays.toString(stateSet) + " found " + idx);
        if (idx < 0) {
            idx = mStateListState.indexOfStateSet(StateSet.WILD_CARD);
        }

        return selectDrawable(idx) || changed;
    }

根据新的状态值，从StateListDrawable实例对象中，找到第一个完全吻合该新状态值的索引下标处
继而，调用selectDrawable()方法去获取索引下标的当前Drawable对象 具体查找算法在 mStateListState.indexOfStateSet(stateSet) 里实现了。基本思路是：查找第一个能完全吻合该新状态的索引下标，如果找到了，则立即返回。

 private int indexOfStateSet(int[] stateSet) {
            int[][] stateSets = this.mStateSets;
            int N = this.getChildCount();

            for(int i = 0; i < N; ++i) {
                if(StateSet.stateSetMatches(stateSets[i], stateSet)) {
                    return i;
                }
            }

            return -1;
        }

再来看看selectDrawable的具体实现

    public boolean selectDrawable(int idx)
    {
        if (idx >= 0 && idx < mDrawableContainerState.mNumChildren) {
            //获取对应索引位置的Drawable对象
            Drawable d = mDrawableContainerState.mDrawables[idx];
            ...
            mCurrDrawable = d; //mCurrDrawable即使当前Drawable对象
            mCurIndex = idx;
            ...
        } else {
           ...
        }
        //请求该View刷新自己,这个方法我们稍后讲解。
        invalidateSelf();
        return true;
    }

该函数的主要功能是选择当前索引下标处的Drawable对象，并保存在mCurrDrawable中。

5、View如何绘制Drawable
经过上面一系列的Drawable状态切换和匹配Drawale，最终我们有了需要重新绘制的pressed状态下的Drawable，此时请求绘制自身并最终会调用View的draw()方法。

public void draw(Canvas canvas) {
        ...

        // draw方法会先绘制背景

        // 不透明才绘制背景
        if (!dirtyOpaque) {  
            final Drawable background = mBackground;
            if (background != null) {
                final int scrollX = mScrollX;
                final int scrollY = mScrollY;

                if (mBackgroundSizeChanged) {
                    background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);
                    mBackgroundSizeChanged = false;
                }

                if ((scrollX | scrollY) == 0) {
                    background.draw(canvas);//开始绘制的动作
                } else {
                    canvas.translate(scrollX, scrollY);
                    background.draw(canvas);//开始绘制的动作
                    canvas.translate(-scrollX, -scrollY);
                }
            }
        }

由于Drawable的draw()方法由其实现类完成，绘制动作各有不同，但最终还是调用canvas.draw…的方法去绘制。

6、关于Drawable.Callback接口

  /**
     * Implement this interface if you want to create an animated drawable that
     * extends {@link android.graphics.drawable.Drawable Drawable}.
     * Upon retrieving a drawable, use
     * {@link Drawable#setCallback(android.graphics.drawable.Drawable.Callback)}
     * to supply your implementation of the interface to the drawable; it uses
     * this interface to schedule and execute animation changes.
     */
    public static interface Callback {
        /**
         * Called when the drawable needs to be redrawn.  A view at this point
         * should invalidate itself (or at least the part of itself where the
         * drawable appears).
         *
         * @param who The drawable that is requesting the update.
         */
        public void invalidateDrawable(Drawable who);

        /**
         * A Drawable can call this to schedule the next frame of its
         * animation.  An implementation can generally simply call
         * {@link android.os.Handler#postAtTime(Runnable, Object, long)} with
         * the parameters <var>(what, who, when)</var> to perform the
         * scheduling.
         *
         * @param who The drawable being scheduled.
         * @param what The action to execute.
         * @param when The time (in milliseconds) to run.  The timebase is
         *             {@link android.os.SystemClock#uptimeMillis}
         */
        public void scheduleDrawable(Drawable who, Runnable what, long when);

        /**
         * A Drawable can call this to unschedule an action previously
         * scheduled with {@link #scheduleDrawable}.  An implementation can
         * generally simply call
         * {@link android.os.Handler#removeCallbacks(Runnable, Object)} with
         * the parameters <var>(what, who)</var> to unschedule the drawable.
         *
         * @param who The drawable being unscheduled.
         * @param what The action being unscheduled.
         */
        public void unscheduleDrawable(Drawable who, Runnable what);
    }

对于CallBack接口，主要看看invalidateDrawable(Drawable who)方法，这个方法的功能是如果Drawable对象的状态发生了变化，会请求View重新绘制，因此我们对应于该View的背景Drawable对象能够重新”绘制“出来。
7、自定义View绘制背景Drawable

public class MyView extends View   
{
    private Context mContext = null;
    private Drawable mBackground = null;
    private boolean mSizeChanged = true;  //视图View布局(layout)大小是否发生变化

    public MyView(Context context)
    {
        super(context);
        mContext = context;       
        initStateListDrawable(); // 初始化图片资源
    }

    // 初始化图片资源
    private void initStateListDrawable()
    {
        //有两种方式获取我们的StateListDrawable对象：
        // 1、代码构建一个StateListDrawable对象
        StateListDrawable statelistDrawable = new StateListDrawable();

        int pressed = android.R.attr.state_pressed;
        int windowfocused = android.R.attr.state_window_focused;
        int enabled = android.R.attr.state_enabled;
        int stateFoucesd = android.R.attr.state_focused;
        //匹配状态时，是一种优先包含的关系。
        // "-"号表示该状态值为false .即不匹配
        statelistDrawable.addState(new int[] { pressed, windowfocused }, 
        mContext.getResources().getDrawable(R.drawable.btn_power_on_pressed));
        statelistDrawable.addState(new int[]{ -pressed, windowfocused }, 
                mContext.getResources().getDrawable(R.drawable.btn_power_on_nor));         
        mBackground = statelistDrawable;
        //必须设置回调，当改变状态时，会回掉该View进行invalidate()刷新操作.
        mBackground.setCallback(this);       
        //取消默认的背景图片，因为我们设置了自己的背景图片了，否则可能造成背景图片重叠。
        this.setBackgroundDrawable(null);
        // 获取方式二、、使用XML获取StateListDrawable对象
        // mBackground = mContext.getResources().getDrawable(R.drawable.tv_background);
    }

    protected void drawableStateChanged()
    {
        Drawable d = mBackground;
        if (d != null && d.isStateful())
        {
            d.setState(getDrawableState());
        }
       super.drawableStateChanged();
    }
    //验证图片是否相等 , 在invalidateDrawable()会调用此方法，我们需要重写该方法。
    protected boolean verifyDrawable(Drawable who)
    {
        return who == mBackground || super.verifyDrawable(who);
    }
    //draw()过程，绘制背景图片...
    public void draw(Canvas canvas)
    {
        if (mBackground != null)
        {
            if(mSizeChanged)
            {
                //设置边界范围
                mBackground.setBounds(0, 0, getRight() - getLeft(), getBottom() - getTop());
                mSizeChanged = false ;
            }
            if ((getScrollX() | getScrollY()) == 0)  //是否偏移
            {
                mBackground.draw(canvas); //绘制当前状态对应的图片
            }
            else
            {
                canvas.translate(getScrollX(), getScrollY());
                mBackground.draw(canvas); //绘制当前状态对应的图片
                canvas.translate(-getScrollX(), -getScrollY());
            }
        }
        super.draw(canvas);
    }
    public void onDraw(Canvas canvas) {    
        ...
    }
}