当前位置 博文首页 > 数据结构和算法:Android TypedArray源码详解

    数据结构和算法:Android TypedArray源码详解

    作者:[db:作者] 时间:2021-08-07 12:52

    尊重原创,转载请标明出处????http://blog.csdn.net/abcdef314159

    在自定义控件的时候,如果我们想额外的添加一些属性,就会用到TypedArray这个类,那么这个类是怎么得到的,以及怎么使用的,这篇讲会详细讲解,下面是我以前自定义控件的一段代码

    TypedArray typedArray = context.obtainStyledAttributes(attrs,R.styleable.myaccount_item_style);
    我们看到TypedArray是通过Context的方法得到的,但要记住完成之后一定要调用recycle()方法进行回收,我们点进去找到最终实现
            public TypedArray obtainStyledAttributes(AttributeSet set,
                    int[] attrs, int defStyleAttr, int defStyleRes) {
                final int len = attrs.length;
                final TypedArray array = TypedArray.obtain(Resources.this, len);
    
                // XXX note that for now we only work with compiled XML files.
                // To support generic XML files we will need to manually parse
                // out the attributes from the XML file (applying type information
                // contained in the resources and such).
                final XmlBlock.Parser parser = (XmlBlock.Parser)set;
                AssetManager.applyStyle(mTheme, defStyleAttr, defStyleRes,
                        parser != null ? parser.mParseState : 0, attrs, array.mData, array.mIndices);
    
                array.mTheme = this;
                array.mXml = parser;
    
    			…………………………
                return array;
            }
    我们先看下面AssetManager的applyStyle方法是native方法,也就是用C++实现的,他会提取自定义控件属性的的值保存TypedArray中的mData数组中,这个数组的大小是由你定义控件属性的个数决定的,是他的6倍,上面的attrs其实就是你自定义属性的个数,我们来看一下

        static TypedArray obtain(Resources res, int len) {
            final TypedArray attrs = res.mTypedArrayPool.acquire();
            if (attrs != null) {
                attrs.mLength = len;
                attrs.mRecycled = false;
    
                final int fullLen = len * AssetManager.STYLE_NUM_ENTRIES;
                if (attrs.mData.length >= fullLen) {
                    return attrs;
                }
    
                attrs.mData = new int[fullLen];
                attrs.mIndices = new int[1 + len];
                return attrs;
            }
    
            return new TypedArray(res,
                    new int[len*AssetManager.STYLE_NUM_ENTRIES],
                    new int[1+len], len);
        }

    他首先会从TypedArray池中获取,如果有就取出,mDate的大小不能小于属性个数的6倍,因为STYLE_NUM_ENTRIES的值为6,如果没有就new一个然后返回,把属性的值提取出来之后我们就可以来操作了,我们先来看一下View类初始化中的一段代码

            final int N = a.getIndexCount();
            for (int i = 0; i < N; i++) {
                int attr = a.getIndex(i);
                switch (attr) {
                    case com.android.internal.R.styleable.View_background:
                        background = a.getDrawable(attr);
                        break;
    					…………………………
                }
            }
    他会把TypedArray中的数据提取出来对View的属性赋值,我们来看一下TypedArray类的构造方法
        /*package*/ TypedArray(Resources resources, int[] data, int[] indices, int len) {
            mResources = resources;
            mMetrics = mResources.mMetrics;
            mAssets = mResources.mAssets;
            mData = data;
            mIndices = indices;
            mLength = len;
        }
    代码很简单,其中mData就是就是从xml文件中提取到的数据,mData的大小是自定义属性个数的6倍,所以这里是每6个作为一组,我们可以看一下上面的obtain方法中data数组的大小是乘以6(STYLE_NUM_ENTRIES)的,这6种类型如下,定义在AssetManager类中,下面的第一个表示每组6个

        /*package*/ static final int STYLE_NUM_ENTRIES = 6;
        /*package*/ static final int STYLE_TYPE = 0;
        /*package*/ static final int STYLE_DATA = 1;
        /*package*/ static final int STYLE_ASSET_COOKIE = 2;
        /*package*/ static final int STYLE_RESOURCE_ID = 3;
        /*package*/ static final int STYLE_CHANGING_CONFIGURATIONS = 4;
        /*package*/ static final int STYLE_DENSITY = 5;
    对应着TypedValue类中的这7中类型,其中string是根据type得到的
        /** The type held by this value, as defined by the constants here.
         *  This tells you how to interpret the other fields in the object. */
        public int type;
    
        /** If the value holds a string, this is it. */
        public CharSequence string;
    
        /** Basic data in the value, interpreted according to {@link #type} */
        public int data;
    
        /** Additional information about where the value came from; only
         *  set for strings. */
        public int assetCookie;
    
        /** If Value came from a resource, this holds the corresponding resource id. */
        public int resourceId;
    
        /** If Value came from a resource, these are the configurations for which
         *  its contents can change. */
        public int changingConfigurations = -1;
    
        /**
         * If the Value came from a resource, this holds the corresponding pixel density.
         * */
        public int density;
    如果我们认真看的时候就会发现obtain方法中对mIndices数组初始化的时候是加1的,因为mIndices数组的第一个保存的是我们所使用属性的个数,记住是使用不是定义,我们来看一下其中的一些代码

        /**
         * Return the number of values in this array.
         */
        public int length() {
            if (mRecycled) {
                throw new RuntimeException("Cannot make calls to a recycled instance!");
            }
    
            return mLength;
        }
    
        /**
         * Return the number of indices in the array that actually have data.
         */
        public int getIndexCount() {
            if (mRecycled) {
                throw new RuntimeException("Cannot make calls to a recycled instance!");
            }
    
            return mIndices[0];
        }
    第一个length返回的是我们所定义属性的个数,因为这个参数是在构造函数中赋值的,传递的是int[] attrs的长度,而这个sttrs就是我们在attrs文件中自定义属性的时候在R文件中自动生成的一个数组。而下面的getIndexCount()方法返回的是我们所使用的属性个数,因为mIndices的数据是从xml文件中提取的,第一个位置保存的是我们使用属性的个数,后面的位置就是我们使用的自定义属性在R文件中生成的id,在看一个方法,也是自定义的时候常用到的

        public int getIndex(int at) {
            if (mRecycled) {
                throw new RuntimeException("Cannot make calls to a recycled instance!");
            }
    
            return mIndices[1+at];
        }
    这个得到的就是自定义属性在R文件中生成的id,剩下的一些方法就是从TypedArray中提取值了,主要有以下几种类型

        <declare-styleable name="CustomTheme">
            <attr name="textView1" format="string" />
            <attr name="textView2" format="boolean" />
            <attr name="textView3" format="integer" />
            <attr name="textView4" format="float" />
            <attr name="textView5" format="color" />
            <attr name="textView6" format="dimension" />
            <attr name="textView7" format="fraction" />
            <attr name="textView8" format="reference" />
            <attr name="textView9" format="enum" />
            <attr name="textView10" format="flags" />
        </declare-styleable>
    TypedArray方法比较多,这里就捡常用的几个来分析一下,在分析之前先看一下下面这个方法
        private CharSequence loadStringValueAt(int index) {
            final int[] data = mData;
            final int cookie = data[index+AssetManager.STYLE_ASSET_COOKIE];
            if (cookie < 0) {
                if (mXml != null) {
                    return mXml.getPooledString(
                        data[index+AssetManager.STYLE_DATA]);
                }
                return null;
            }
            return mAssets.getPooledStringForCookie(cookie, data[index+AssetManager.STYLE_DATA]);
        }
    上面所说的每6个一组,其中每组下标为STYLE_ASSET_COOKIE(2)的是用来标记缓存的,并且是只对String类型的,我们来看一下
        private boolean getValueAt(int index, TypedValue outValue) {
            final int[] data = mData;
            final int type = data[index+AssetManager.STYLE_TYPE];
            if (type == TypedValue.TYPE_NULL) {
                return false;
            }
            outValue.type = type;
            outValue.data = data[index+AssetManager.STYLE_DATA];
            outValue.assetCookie = data[index+AssetManager.STYLE_ASSET_COOKIE];
            outValue.resourceId = data[index+AssetManager.STYLE_RESOURCE_ID];
            outValue.changingConfigurations = data[index+AssetManager.STYLE_CHANGING_CONFIGURATIONS];
            outValue.density = data[index+AssetManager.STYLE_DENSITY];
            outValue.string = (type == TypedValue.TYPE_STRING) ? loadStringValueAt(index) : null;
            return true;
        }
    上面这个方法是把mData指定范围的6个数据提取到outValue中,其中string值通过type类型得到的,我们再来看一下assetCookie的注释

        /** Additional information about where the value came from; only
         *  set for strings. */
        public int assetCookie;
    所以他只针对String类型,我们再来看一下String类型的注释

        /** The <var>string</var> field holds string data.  In addition, if
         *  <var>data</var> is non-zero then it is the string block
         *  index of the string and <var>assetCookie</var> is the set of
         *  assets the string came from. */
        public static final int TYPE_STRING = 0x03;
    所以他只针对string类型的数据进行提取,比如text,String,color等,color可以是string类型也可以是int类型,还看上面的loadStringValueAt方法,如果cookie小于0,说明没有缓存,就会从xml中解析,否则就从缓存中取
        /*package*/ final CharSequence getPooledStringForCookie(int cookie, int id) {
            // Cookies map to string blocks starting at 1.
            return mStringBlocks[cookie - 1].get(id);
    我们来看一下是怎么从xml中解析的,看到上面的obtainStyledAttributes方法,会发现这样一段代码?array.mXml = parser;其中parser就是View及其子类在初始化的时候传递的AttributeSet,我们在前面的《Android LayoutInflater源码分析及使用(二)》中讲到,View及其子类创建的时候是通过反射来初始化的,我们来回顾一下

       public final View createView(String name, String prefix, AttributeSet attrs)
                throws ClassNotFoundException, InflateException {
            Constructor<? extends View> constructor = sConstructorMap.get(name);
            Class<? extends View> clazz = null;
    
            try {
    				…………………………
                    constructor = clazz.getConstructor(mConstructorSignature);
    				…………………………
    
                Object[] args = mConstructorArgs;
                args[1] = attrs;
    
                constructor.setAccessible(true);
                final View view = constructor.newInstance(args);
    			…………………………
                return view;
    
            } catch (NoSuchMethodException e) {
               …………………………
            } finally {
                Trace.traceEnd(Trace.TRACE_TAG_VIEW);
            }
        }
    其中attrs是通过Resource的loadXmlResourceParser方法加载的,我们看一下
        /*package*/ XmlResourceParser loadXmlResourceParser(int id, String type)
                throws NotFoundException {
            synchronized (mAccessLock) {
                TypedValue value = mTmpValue;
                if (value == null) {
                    mTmpValue = value = new TypedValue();
                }
                getValue(id, value, true);
                if (value.type == TypedValue.TYPE_STRING) {
                    return loadXmlResourceParser(value.string.toString(), id,
                            value.assetCookie, type);
                }
                throw new NotFoundException(
                        "Resource ID #0x" + Integer.toHexString(id) + " type #0x"
                        + Integer.toHexString(value.type) + " is not valid");
            }
        }
    剩下的就是涉及到Xml的解析,这里就不在作深入探讨,言归正传,还回到刚才的loadStringValueAt方法,如果缓存中存在就从缓存中去,如果不存在就通过xml解析获取。下面在看一下一些常用的方法,其中getText(int index)和getString(int index)差不多,我们就来看一下getString(int index)方法
        public String getString(int index) {
            if (mRecycled) {
                throw new RuntimeException("Cannot make calls to a recycled instance!");
            }
    
            index *= AssetManager.STYLE_NUM_ENTRIES;
            final int[] data = mData;
            final int type = data[index+AssetManager.STYLE_TYPE];
            if (type == TypedValue.TYPE_NULL) {
                return null;
            } else if (type == TypedValue.TYPE_STRING) {
                return loadStringValueAt(index).toString();
            }
    
            TypedValue v = mValue;
            if (getValueAt(index, v)) {
                Log.w(Resources.TAG, "Converting to string: " + v);
                CharSequence cs = v.coerceToString();
                return cs != null ? cs.toString() : null;
            }
            Log.w(Resources.TAG, "getString of bad type: 0x"
                  + Integer.toHexString(type));
            return null;
        }

    上面的index要乘以6(STYLE_NUM_ENTRIES),因为是每6个一组的,如果type为null就返回空,如果为String类型就会调用loadStringValueAt方法获取我们设置的值。有一点要注意,如果我们在attrs中设置的format类型和我们自定义设置的参数不符的话,当运行的时候是会报错的,必须要设置相符并clean才能解决。否则就执行下面的方法,强制转换为字符串,代码比较简单,这里就不再贴出。在来看下一个bool类型和int类型的,由于这两个差不多,就随便挑一个

        public int getInt(int index, int defValue) {
            index *= AssetManager.STYLE_NUM_ENTRIES;
            final int[] data = mData;
            final int type = data[index+AssetManager.STYLE_TYPE];
            if (type == TypedValue.TYPE_NULL) {
                return defValue;
            } else if (type >= TypedValue.TYPE_FIRST_INT
                && type <= TypedValue.TYPE_LAST_INT) {
                return data[index+AssetManager.STYLE_DATA];
            }
    
            TypedValue v = mValue;
            if (getValueAt(index, v)) {
                Log.w(Resources.TAG, "Converting to int: " + v);
                return XmlUtils.convertValueToInt(
                    v.coerceToString(), defValue);
            }
            Log.w(Resources.TAG, "getInt of bad type: 0x"
                  + Integer.toHexString(type));
            return defValue;
        }

    上面的类型如果大于TYPE_FIRST_INT并且小于TYPE_LAST_INT的时候就从mDate中提取值,这个不知道为什么要这样写,不过从他的范围来看也就int,Boolean,color三种是这样取值的
        /** Identifies the start of integer values that were specified as
         *  color constants (starting with '#'). */
        public static final int TYPE_FIRST_COLOR_INT = 0x1c;
    
        /** The <var>data</var> field holds a color that was originally
         *  specified as #aarrggbb. */
        public static final int TYPE_INT_COLOR_ARGB8 = 0x1c;
        /** The <var>data</var> field holds a color that was originally
         *  specified as #rrggbb. */
        public static final int TYPE_INT_COLOR_RGB8 = 0x1d;
        /** The <var>data</var> field holds a color that was originally
         *  specified as #argb. */
        public static final int TYPE_INT_COLOR_ARGB4 = 0x1e;
        /** The <var>data</var> field holds a color that was originally
         *  specified as #rgb. */
        public static final int TYPE_INT_COLOR_RGB4 = 0x1f;
    
        /** Identifies the end of integer values that were specified as color
         *  constants. */
        public static final int TYPE_LAST_COLOR_INT = 0x1f;
    
        /** Identifies the end of plain integer values. */
        public static final int TYPE_LAST_INT = 0x1f;
    如果范围不在TYPE_FIRST_INT和TYPE_LAST_INT之间,就会把mData指定位置上的值提取到TypedValue中,然后在强制转化,如果没有提取到就会返回一个默认值,因为如果在attrs中定义但没有用到,就会返回一个默认值。我们来看一下是怎么转化的
        public static final int
        convertValueToInt(CharSequence charSeq, int defaultValue)
        {
            if (null == charSeq)
                return defaultValue;
    
            String nm = charSeq.toString();
    
            // XXX This code is copied from Integer.decode() so we don't
            // have to instantiate an Integer!
    
            int value;
            int sign = 1;
            int index = 0;
            int len = nm.length();
            int base = 10;
    
            if ('-' == nm.charAt(0)) {
                sign = -1;
                index++;
            }
    
            if ('0' == nm.charAt(index)) {
                //  Quick check for a zero by itself
                if (index == (len - 1))
                    return 0;
    
                char    c = nm.charAt(index + 1);
    
                if ('x' == c || 'X' == c) {
                    index += 2;
                    base = 16;
                } else {
                    index++;
                    base = 8;
                }
            }
            else if ('#' == nm.charAt(index))
            {
                index++;
                base = 16;
            }
    
            return Integer.parseInt(nm.substring(index), base) * sign;
        }
    这个很好理解,转化为int类型有0开头的8进制,0x开头的16进制,还有#开头的color值,如果转化之前是负数,转化之后还要乘以-1(sign)。再来看一个
        public int getColor(int index, int defValue) {
            index *= AssetManager.STYLE_NUM_ENTRIES;
            final int[] data = mData;
            final int type = data[index+AssetManager.STYLE_TYPE];
            if (type == TypedValue.TYPE_NULL) {
                return defValue;
            } else if (type >= TypedValue.TYPE_FIRST_INT
                && type <= TypedValue.TYPE_LAST_INT) {
                return data[index+AssetManager.STYLE_DATA];
            } else if (type == TypedValue.TYPE_STRING) {
                final TypedValue value = mValue;
                if (getValueAt(index, value)) {
                    ColorStateList csl = mResources.loadColorStateList(
                            value, value.resourceId);
                    return csl.getDefaultColor();
                }
                return defValue;
            }
    
            throw new UnsupportedOperationException("Can't convert to color: type=0x"
                    + Integer.toHexString(type));
        }

    这个就不用多说了,因为color有String和int两种类型,如果是String类型就会返回ColorStateList的默认值,因为ColorStateList可能有好几种类型,但必须都是false的才是默认的,下面随便看一个,下面这些提取之后默认的就是green,因为只有他的所有状态都是false。

    <?xml version="1.0" encoding="utf-8"?>
    <selector xmlns:android="http://schemas.android.com/apk/res/android">
    
        <item android:state_pressed="true" android:color="@color/blue"/>
        <item android:state_pressed="false" android:state_selected="true" android:color="@color/yellow"/>
        <item android:state_pressed="false" android:state_selected="false" android:color="@color/green"/>
    
    </selector>
    下面在看最后一个方法
        public int getLayoutDimension(int index, String name) {
            index *= AssetManager.STYLE_NUM_ENTRIES;
            final int[] data = mData;
            final int type = data[index+AssetManager.STYLE_TYPE];
            if (type >= TypedValue.TYPE_FIRST_INT
                    && type <= TypedValue.TYPE_LAST_INT) {
                return data[index+AssetManager.STYLE_DATA];
            } else if (type == TypedValue.TYPE_DIMENSION) {
                return TypedValue.complexToDimensionPixelSize(
                    data[index+AssetManager.STYLE_DATA], mResources.mMetrics);
            }
    
            throw new RuntimeException(getPositionDescription()
                    + ": You must supply a " + name + " attribute.");
        }
    看方法名大概就知道是获取layout的尺寸的,大致看一下,在ViewGroup中
            protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
                width = a.getLayoutDimension(widthAttr, "layout_width");
                height = a.getLayoutDimension(heightAttr, "layout_height");
            }
    其中获取到的值有3种,一种是精确的我们给的大于0的,一种是-1(MATCH_PARENT),另一种是-2(WRAP_CONTENT),记得在讲到《Android LayoutInflater源码分析及使用(二)》的时候说到,xml的属性除了宽和高以外在初始化的时候基本上都能提取到,但宽和高是不行的,因为他是最终计算出来的,如果大家自定义View继承View的时候,要必须重写onMeasure方法,重新计算他的宽和高,如果我们不计算,当我们使用MATCH_PARENT或WRAP_CONTENT属性的时候,结果是完全一样的,尺寸都是填满剩下的屏幕,如果不重写onMeasure方法,在xml文件中把他的宽和高都写死也行,但这样不够灵活,我们来看一下为什么要重写
        public static int getDefaultSize(int size, int measureSpec) {
            int result = size;
            int specMode = MeasureSpec.getMode(measureSpec);
            int specSize = MeasureSpec.getSize(measureSpec);
    
            switch (specMode) {
            case MeasureSpec.UNSPECIFIED:
                result = size;
                break;
            case MeasureSpec.AT_MOST:
            case MeasureSpec.EXACTLY:
                result = specSize;
                break;
            }
            return result;
        }
    我们看到View中的getDefaultSize方法,AT_MOST和EXACTLY返回的结果都是一样的,如果想看建议看一下ViewGroup的getChildMeasureSpec方法,这个就不在贴出,可以自己去看。OK,TypedArray中剩下的方法基本上也都非常相似,这里就不在一一讲述。


    cs
    上一篇:没有了
    下一篇:没有了