深度揭秘：Android View 自定义属性原理大剖析

深度揭秘：Android View 自定义属性原理大剖析

一、引言

在 Android 开发中，系统提供的 View 属性往往不能完全满足我们多样化的需求。这时，自定义 View 属性就显得尤为重要。通过自定义属性，我们可以让 View 具备更丰富的特性，使应用的界面和交互更加灵活多样。

本文将从源码级别深入剖析 Android View 自定义属性的原理。我们会详细介绍自定义属性的定义、声明、获取和使用的全过程，结合具体的源码进行分析，让开发者能够透彻理解其中的奥秘，从而在实际开发中更加得心应手地运用自定义属性。

二、自定义属性概述

2.1 自定义属性的作用

自定义属性允许开发者为 View 或 ViewGroup 添加额外的特性，这些特性可以在 XML 布局文件中进行配置，也可以在代码中动态设置。例如，我们可以为一个自定义的 Button 控件添加一个"rippleColor"属性，用于设置点击时的水波纹颜色，这样在不同的界面中就可以方便地使用不同的水波纹颜色。

2.2 自定义属性的应用场景

• 个性化界面设计：当系统提供的属性无法满足特定的界面设计需求时，通过自定义属性可以实现独特的视觉效果。比如，为一个 ImageView 添加圆角属性，使其显示为圆角图片。
• 提高代码复用性：将一些常用的属性封装到自定义 View 中，通过自定义属性进行配置，这样可以在不同的地方复用该 View，减少代码重复。
• 增强交互性：通过自定义属性可以为 View 添加一些交互相关的特性，如触摸反馈效果、动画效果等。

三、自定义属性的定义与声明

3.1 定义自定义属性集合

在 Android 中，我们需要在 res/values 目录下创建一个 XML 文件（通常命名为 attrs.xml）来定义自定义属性集合。以下是一个简单的示例：

<!-- res/values/attrs.xml -->
<resources>
    <!-- 定义一个名为 CustomView 的属性集合 -->
    <declare-styleable name="CustomView">
        <!-- 定义一个名为 customTextColor 的属性，类型为颜色 -->
        <attr name="customTextColor" format="color" />
        <!-- 定义一个名为 customTextSize 的属性，类型为尺寸 -->
        <attr name="customTextSize" format="dimension" />
    </declare-styleable>
</resources>

在上述代码中，我们使用 <declare-styleable> 标签定义了一个名为 CustomView 的属性集合，其中包含了两个属性：customTextColor 和 customTextSize。format 属性指定了属性的类型，常见的类型有 color（颜色）、dimension（尺寸）、string（字符串）等。

3.2 声明自定义属性的源码分析

在 Android 系统中，declare-styleable 标签的解析是在资源编译阶段完成的。Aapt（Android Asset Packaging Tool）工具会将 attrs.xml 文件中的内容解析并生成相应的资源类。

当我们定义了 attrs.xml 文件后，Aapt 会生成一个名为 R.styleable 的静态内部类，其中包含了我们定义的属性集合和属性。以下是生成的 R.java 文件的部分内容示例：

public final class R {
    public static final class styleable {
        public static final int[] CustomView = {
            0x7f010000, // customTextColor
            0x7f010001  // customTextSize
        };
        public static final int CustomView_customTextColor = 0;
        public static final int CustomView_customTextSize = 1;
    }
}

在上述代码中，R.styleable.CustomView 是一个整型数组，包含了 CustomView 属性集合中所有属性的资源 ID。R.styleable.CustomView_customTextColor 和 R.styleable.CustomView_customTextSize 分别是 customTextColor 和 customTextSize 属性在数组中的索引。

四、在自定义 View 中使用自定义属性

4.1 自定义 View 的构造函数

在自定义 View 中，我们需要在构造函数中获取自定义属性的值。以下是一个简单的自定义 View 示例：

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.util.AttributeSet;
import android.view.View;
import com.example.customview.R;

public class CustomView extends View {
    // 自定义的文本颜色
    private int customTextColor;
    // 自定义的文本大小
    private float customTextSize;

    public CustomView(Context context) {
        super(context);
        // 调用包含 AttributeSet 的构造函数
        init(context, null);
    }

    public CustomView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // 调用初始化方法
        init(context, attrs);
    }

    public CustomView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 调用初始化方法
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        if (attrs != null) {
            // 获取属性集合
            TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.CustomView);
            try {
                // 获取 customTextColor 属性的值，默认值为黑色
                customTextColor = typedArray.getColor(R.styleable.CustomView_customTextColor, Color.BLACK);
                // 获取 customTextSize 属性的值，默认值为 16sp
                customTextSize = typedArray.getDimension(R.styleable.CustomView_customTextSize, 16 * getResources().getDisplayMetrics().scaledDensity);
            } finally {
                // 回收 TypedArray 对象
                typedArray.recycle();
            }
        }
    }
}

在上述代码中，我们定义了一个 CustomView 类，包含三个构造函数。在 init 方法中，我们使用 context.obtainStyledAttributes 方法获取属性集合，然后通过 TypedArray 对象获取自定义属性的值。最后，我们使用 typedArray.recycle() 方法回收 TypedArray 对象，以避免内存泄漏。

4.2 obtainStyledAttributes 方法的源码分析

// Context 类中的 obtainStyledAttributes 方法
public TypedArray obtainStyledAttributes(AttributeSet set, int[] attrs) {
    // 获取资源管理器
    Resources.Theme theme = getTheme();
    if (theme == null) {
        // 如果没有主题，直接从资源中获取属性
        return getResources().obtainAttributes(set, attrs);
    }
    // 从主题中获取属性
    return theme.obtainStyledAttributes(set, attrs, 0, 0);
}

在 Context 类的 obtainStyledAttributes 方法中，首先获取当前的主题。如果没有主题，则直接从资源中获取属性；否则，从主题中获取属性。

// Resources 类中的 obtainAttributes 方法
public TypedArray obtainAttributes(AttributeSet set, int[] attrs) {
    // 创建一个 TypedArray 对象
    TypedArray array = TypedArray.obtain(this, attrs.length);
    // 解析属性集合
    array.parseStyleAttributes(set, attrs);
    return array;
}

在 Resources 类的 obtainAttributes 方法中，首先创建一个 TypedArray 对象，然后调用 parseStyleAttributes 方法解析属性集合。

// TypedArray 类中的 parseStyleAttributes 方法
void parseStyleAttributes(AttributeSet set, int[] attrs) {
    final int N = attrs.length;
    for (int i = 0; i < N; i++) {
        final int resId = attrs[i];
        // 获取属性的值
        final String value = set.getAttributeValue(null, getAttributeName(resId));
        if (value != null) {
            // 处理属性值
            handleValue(resId, value);
        }
    }
}

在 TypedArray 类的 parseStyleAttributes 方法中，遍历属性集合中的每个属性，获取属性的值，并调用 handleValue 方法处理属性值。

4.3 获取自定义属性值的方法源码分析

// TypedArray 类中的 getColor 方法
public int getColor(int index, int defValue) {
    // 获取属性的值
    final TypedValue value = mValue;
    if (getValueAt(index, value)) {
        if (value.type == TypedValue.TYPE_INT_COLOR_ARGB8 ||
                value.type == TypedValue.TYPE_INT_COLOR_ARGB4 ||
                value.type == TypedValue.TYPE_INT_COLOR_RGB8 ||
                value.type == TypedValue.TYPE_INT_COLOR_RGB4) {
            // 如果属性类型是颜色，返回颜色值
            return value.data;
        }
    }
    // 如果属性值无效，返回默认值
    return defValue;
}

在 TypedArray 类的 getColor 方法中，首先获取属性的值，然后判断属性的类型是否为颜色。如果是颜色类型，则返回颜色值；否则，返回默认值。

// TypedArray 类中的 getDimension 方法
public float getDimension(int index, float defValue) {
    // 获取属性的值
    final TypedValue value = mValue;
    if (getValueAt(index, value)) {
        if (value.type == TypedValue.TYPE_DIMENSION) {
            // 如果属性类型是尺寸，返回尺寸值
            return TypedValue.complexToDimension(value.data, mResources.getDisplayMetrics());
        }
    }
    // 如果属性值无效，返回默认值
    return defValue;
}

在 TypedArray 类的 getDimension 方法中，首先获取属性的值，然后判断属性的类型是否为尺寸。如果是尺寸类型，则调用 TypedValue.complexToDimension 方法将属性值转换为实际的尺寸值；否则，返回默认值。

五、在 XML 布局文件中使用自定义属性

5.1 引入命名空间

在 XML 布局文件中使用自定义属性时，需要引入自定义属性的命名空间。命名空间的格式为 xmlns:自定义前缀="http://schemas.android.com/apk/res-auto"，其中 自定义前缀 可以是任意合法的名称。以下是一个示例：

<!-- res/layout/activity_main.xml -->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <com.example.customview.CustomView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:customTextColor="#FF0000"
        app:customTextSize="20sp" />
</LinearLayout>

在上述代码中，我们引入了自定义属性的命名空间 xmlns:app="http://schemas.android.com/apk/res-auto"，并使用 app 作为前缀来引用自定义属性。

5.2 XML 布局文件解析的源码分析

在 Android 系统中，XML 布局文件的解析是通过 LayoutInflater 类完成的。以下是 LayoutInflater 类的 inflate 方法的部分源码：

// LayoutInflater 类中的 inflate 方法
public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
    synchronized (mConstructorArgs) {
        final Context inflaterContext = mContext;
        final AttributeSet attrs = Xml.asAttributeSet(parser);
        Context lastContext = (Context) mConstructorArgs[0];
        mConstructorArgs[0] = inflaterContext;
        View result = root;

        try {
            // 解析 XML 文件的开始标签
            advanceToRootNode(parser);
            final String name = parser.getName();

            if (TAG_MERGE.equals(name)) {
                // 如果是 <merge> 标签，直接解析子节点
                if (root == null || !attachToRoot) {
                    throw new InflateException("<merge /> can be used only with a valid "
                            + "ViewGroup root and attachToRoot=true");
                }
                rInflate(parser, root, inflaterContext, attrs, false);
            } else {
                // 创建根 View
                final View temp = createViewFromTag(root, name, inflaterContext, attrs);

                ViewGroup.LayoutParams params = null;

                if (root != null) {
                    // 获取根 View 的布局参数
                    params = root.generateLayoutParams(attrs);
                    if (!attachToRoot) {
                        // 如果不附加到根 View，设置布局参数
                        temp.setLayoutParams(params);
                    }
                }

                // 解析子节点
                rInflateChildren(parser, temp, attrs, true);

                if (root != null && attachToRoot) {
                    // 如果附加到根 View，将 View 添加到根 View 中
                    root.addView(temp, params);
                }

                if (root == null || !attachToRoot) {
                    result = temp;
                }
            }

        } catch (XmlPullParserException e) {
            final InflateException ie = new InflateException(e.getMessage(), e);
            ie.setStackTrace(EMPTY_STACK_TRACE);
            throw ie;
        } catch (Exception e) {
            final InflateException ie = new InflateException(
                    getParserStateDescription(parser, attrs), e);
            ie.setStackTrace(EMPTY_STACK_TRACE);
            throw ie;
        } finally {
            // 重置构造函数参数
            mConstructorArgs[0] = lastContext;
        }

        return result;
    }
}

在 inflate 方法中，首先解析 XML 文件的开始标签，然后根据标签名创建相应的 View。在创建 View 时，会将 XML 文件中的属性传递给 View 的构造函数，从而实现自定义属性的设置。

六、自定义属性的继承与覆盖

6.1 自定义属性的继承

在 Android 中，自定义属性可以继承自父类的属性集合。例如，我们可以定义一个 CustomTextView 类，继承自 TextView，并在其属性集合中添加一些自定义属性：

<!-- res/values/attrs.xml -->
<resources>
    <!-- 定义一个名为 CustomTextView 的属性集合，继承自 TextView -->
    <declare-styleable name="CustomTextView" parent="android:attr/textViewStyle">
        <!-- 定义一个名为 customDrawableTint 的属性，类型为颜色 -->
        <attr name="customDrawableTint" format="color" />
    </declare-styleable>
</resources>

在上述代码中，我们定义了一个 CustomTextView 属性集合，继承自 android:attr/textViewStyle，并添加了一个自定义属性 customDrawableTint。

6.2 自定义属性的覆盖

在自定义 View 中，我们可以覆盖父类的属性。例如，我们可以为 CustomTextView 类覆盖 android:textColor 属性：

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.util.AttributeSet;
import android.widget.TextView;
import com.example.customview.R;

public class CustomTextView extends TextView {
    // 自定义的 drawable 着色颜色
    private int customDrawableTint;

    public CustomTextView(Context context) {
        super(context);
        // 调用包含 AttributeSet 的构造函数
        init(context, null);
    }

    public CustomTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // 调用初始化方法
        init(context, attrs);
    }

    public CustomTextView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 调用初始化方法
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        if (attrs != null) {
            // 获取属性集合
            TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.CustomTextView);
            try {
                // 获取 customDrawableTint 属性的值，默认值为黑色
                customDrawableTint = typedArray.getColor(R.styleable.CustomTextView_customDrawableTint, Color.BLACK);
                // 覆盖 android:textColor 属性
                int textColor = typedArray.getColor(R.styleable.CustomTextView_android_textColor, getTextColors().getDefaultColor());
                setTextColor(textColor);
            } finally {
                // 回收 TypedArray 对象
                typedArray.recycle();
            }
        }
    }
}

在上述代码中，我们在 init 方法中获取 android:textColor 属性的值，并调用 setTextColor 方法覆盖父类的 textColor 属性。

七、自定义属性的类型及使用

7.1 常见的自定义属性类型

• color ：颜色类型，用于设置颜色值，如 #FF0000 表示红色。
• dimension ：尺寸类型，用于设置尺寸值，如 20sp、10dp 等。
• string ：字符串类型，用于设置文本内容，如 "Hello World"。
• boolean ：布尔类型，用于设置布尔值，如 true 或 false。
• integer ：整数类型，用于设置整数值，如 10。
• reference ：引用类型，用于引用其他资源，如 @drawable/icon 表示引用一个 Drawable 资源。

7.2 不同类型属性的使用示例

<!-- res/values/attrs.xml -->
<resources>
    <!-- 定义一个名为 CustomImageView 的属性集合 -->
    <declare-styleable name="CustomImageView">
        <!-- 定义一个名为 customImageTint 的属性，类型为颜色 -->
        <attr name="customImageTint" format="color" />
        <!-- 定义一个名为 customImagePadding 的属性，类型为尺寸 -->
        <attr name="customImagePadding" format="dimension" />
        <!-- 定义一个名为 customImageText 的属性，类型为字符串 -->
        <attr name="customImageText" format="string" />
        <!-- 定义一个名为 customImageClickable 的属性，类型为布尔 -->
        <attr name="customImageClickable" format="boolean" />
        <!-- 定义一个名为 customImageResource 的属性，类型为引用 -->
        <attr name="customImageResource" format="reference" />
    </declare-styleable>
</resources>

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.util.AttributeSet;
import android.widget.ImageView;
import com.example.customview.R;

public class CustomImageView extends ImageView {
    // 自定义的图片着色颜色
    private int customImageTint;
    // 自定义的图片内边距
    private int customImagePadding;
    // 自定义的图片文本
    private String customImageText;
    // 自定义的图片是否可点击
    private boolean customImageClickable;
    // 自定义的图片资源
    private int customImageResource;

    public CustomImageView(Context context) {
        super(context);
        // 调用包含 AttributeSet 的构造函数
        init(context, null);
    }

    public CustomImageView(Context context, AttributeSet attrs) {
        super(context, attrs);
        // 调用初始化方法
        init(context, attrs);
    }

    public CustomImageView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 调用初始化方法
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        if (attrs != null) {
            // 获取属性集合
            TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.CustomImageView);
            try {
                // 获取 customImageTint 属性的值，默认值为黑色
                customImageTint = typedArray.getColor(R.styleable.CustomImageView_customImageTint, Color.BLACK);
                // 获取 customImagePadding 属性的值，默认值为 0
                customImagePadding = typedArray.getDimensionPixelSize(R.styleable.CustomImageView_customImagePadding, 0);
                // 获取 customImageText 属性的值，默认值为空字符串
                customImageText = typedArray.getString(R.styleable.CustomImageView_customImageText);
                // 获取 customImageClickable 属性的值，默认值为 false
                customImageClickable = typedArray.getBoolean(R.styleable.CustomImageView_customImageClickable, false);
                // 获取 customImageResource 属性的值，默认值为 0
                customImageResource = typedArray.getResourceId(R.styleable.CustomImageView_customImageResource, 0);

                // 设置图片着色颜色
                setColorFilter(customImageTint);
                // 设置图片内边距
                setPadding(customImagePadding, customImagePadding, customImagePadding, customImagePadding);
                // 设置图片资源
                if (customImageResource != 0) {
                    setImageResource(customImageResource);
                }
                // 设置图片是否可点击
                setClickable(customImageClickable);
            } finally {
                // 回收 TypedArray 对象
                typedArray.recycle();
            }
        }
    }
}

在上述代码中，我们定义了一个 CustomImageView 类，包含了多种类型的自定义属性，并在 init 方法中获取这些属性的值，然后根据属性值进行相应的设置。

八、自定义属性的性能优化

8.1 减少属性的定义

在定义自定义属性时，应尽量减少不必要的属性。过多的属性会增加资源编译和解析的时间，影响应用的性能。只定义真正需要的属性，避免定义一些很少使用的属性。

8.2 合理使用默认值

为自定义属性设置合理的默认值可以减少在 XML 布局文件中重复设置属性的工作量，同时也可以提高代码的可读性和可维护性。在获取属性值时，如果用户没有设置属性值，则使用默认值。

8.3 避免频繁获取属性值

在自定义 View 的代码中，应避免频繁获取属性值。可以在初始化时获取属性值，并将其保存到成员变量中，在后续的操作中直接使用成员变量，避免重复获取属性值。

8.4 资源复用

对于一些引用类型的属性，如 Drawable 资源，应尽量复用资源，避免重复创建。可以使用 Resources.getDrawable 方法获取 Drawable 资源，并进行缓存，以便在需要时直接使用。

九、总结与展望

9.1 总结

本文从源码级别深入剖析了 Android View 自定义属性的原理，涵盖了自定义属性的定义、声明、获取和使用的全过程。通过自定义属性，我们可以为 View 或 ViewGroup 添加额外的特性，使应用的界面和交互更加灵活多样。

在自定义属性的定义和声明阶段，我们使用 declare-styleable 标签定义属性集合，并通过 Aapt 工具生成相应的资源类。在自定义 View 中，我们通过 obtainStyledAttributes 方法获取属性集合，并使用 TypedArray 对象获取自定义属性的值。在 XML 布局文件中，我们引入自定义属性的命名空间，并使用自定义前缀引用自定义属性。

同时，我们还介绍了自定义属性的继承与覆盖、不同类型属性的使用以及性能优化等方面的内容。通过合理使用自定义属性和进行性能优化，可以提高应用的开发效率和性能。

9.2 展望

随着 Android 技术的不断发展，自定义属性的功能和应用场景也将不断拓展。未来，可能会出现以下几个发展趋势：

9.2.1 更加智能的属性配置

未来的 Android 开发工具可能会提供更加智能的属性配置功能，例如根据 View 的类型自动推荐合适的属性，或者通过可视化界面进行属性配置，减少开发者手动编写 XML 代码的工作量。

9.2.2 与其他技术的融合

自定义属性可能会与其他 Android 技术，如动画、数据绑定等进行更深入的融合。例如，通过自定义属性可以更加方便地配置动画效果，或者实现数据绑定的属性同步。

9.2.3 跨平台的自定义属性支持

随着跨平台开发框架的不断发展，可能会出现对跨平台自定义属性的支持。开发者可以定义一套通用的自定义属性，在不同的平台上实现相同的效果，提高开发效率。

9.2.4 性能优化的进一步提升

未来的 Android 系统可能会对自定义属性的性能进行进一步优化，减少资源编译和解析的时间，提高应用的启动速度和运行效率。

总之，深入理解 Android View 自定义属性的原理对于开发者来说至关重要。通过不断学习和实践，开发者能够更好地运用自定义属性，为用户带来更加优质、灵活和个性化的应用体验。同时，关注自定义属性的发展趋势，不断探索新的应用场景和技术方法，将有助于开发者在未来的 Android 开发领域中保持竞争力。