深度剖析：Android Canvas 使用原理全揭秘

深度剖析：Android Canvas 使用原理全揭秘

一、引言

在 Android 开发中，Canvas（画布）是一个极为关键的概念，它为开发者提供了一个强大的绘图平台，使得我们能够在屏幕上绘制各种复杂的图形、图像和文本。无论是实现炫酷的动画效果，还是开发自定义的视图组件，Canvas 都发挥着至关重要的作用。

本文将从源码级别深入分析 Android Canvas 的使用原理，详细介绍 Canvas 的基本概念、绘图流程、各种绘图方法的实现原理以及相关的状态管理和变换操作。通过对源码的剖析，帮助开发者更好地理解 Canvas 的工作机制，从而更加灵活和高效地运用它来实现各种绘图需求。

二、Android Canvas 概述

2.1 Canvas 的定义和作用

Canvas 可以理解为一个绘图板，它提供了一系列的绘图方法，如绘制直线、矩形、圆形、文本等。开发者可以通过调用这些方法在 Canvas 上进行绘图操作，最终将绘制的内容显示在屏幕上。Canvas 的主要作用包括：

• 自定义视图绘制 ：开发者可以创建自定义的 View 或 ViewGroup，并重写其 onDraw 方法，在该方法中使用 Canvas 进行绘图，从而实现独特的界面效果。
• 动画效果实现：通过不断地在 Canvas 上绘制不同的图形和图像，并结合动画框架，可以实现各种流畅的动画效果，如旋转、缩放、平移等。
• 图像编辑和处理：可以使用 Canvas 对图像进行裁剪、缩放、合成等操作，实现图像的编辑和处理功能。

2.2 Canvas 的基本使用流程

在 Android 中，使用 Canvas 进行绘图的基本流程如下：

1. 创建或获取 Canvas 对象 ：通常在自定义 View 的 onDraw 方法中，系统会自动传入一个 Canvas 对象，我们可以直接使用该对象进行绘图操作。
2. 设置绘图属性：在绘图之前，需要设置一些绘图属性，如画笔的颜色、样式、字体等，以控制绘图的效果。
3. 调用绘图方法 ：根据需要调用 Canvas 提供的各种绘图方法，如 drawLine、drawRect、drawCircle 等，进行具体的绘图操作。
4. 提交绘图结果：绘图完成后，系统会自动将 Canvas 上的内容显示在屏幕上。

三、Canvas 的创建和初始化

3.1 在自定义 View 中获取 Canvas 对象

在自定义 View 中，我们通常会重写 onDraw 方法，该方法会传入一个 Canvas 对象，我们可以直接使用该对象进行绘图。以下是一个简单的自定义 View 示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class CustomView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public CustomView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为红色
        mPaint.setColor(Color.RED);
        // 设置画笔的样式为填充
        mPaint.setStyle(Paint.Style.FILL);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 在 Canvas 上绘制一个圆形
        canvas.drawCircle(100, 100, 50, mPaint);
    }
}

在上述代码中，我们创建了一个自定义的 CustomView 类，并重写了 onDraw 方法。在 onDraw 方法中，系统会自动传入一个 Canvas 对象，我们使用该对象调用 drawCircle 方法绘制了一个圆形。

3.2 Canvas 对象的创建源码分析

在 Android 系统中，Canvas 对象的创建是由系统底层完成的。在 View 类的 draw 方法中，会调用 dispatchDraw 方法来绘制子视图，在这个过程中会创建并传入 Canvas 对象。以下是 View 类的 draw 方法的部分源码：

// View 类的 draw 方法
public void draw(Canvas canvas) {
    // 绘制背景
    drawBackground(canvas);

    // 绘制自身内容
    onDraw(canvas);

    // 绘制子视图
    dispatchDraw(canvas);

    // 绘制装饰（如滚动条等）
    onDrawForeground(canvas);
}

// ViewGroup 类的 dispatchDraw 方法
@Override
protected void dispatchDraw(Canvas canvas) {
    final int childrenCount = mChildrenCount;
    final View[] children = mChildren;
    for (int i = 0; i < childrenCount; i++) {
        final View child = children[i];
        if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
            // 为子视图创建一个新的 Canvas 对象
            drawChild(canvas, child, drawingTime);
        }
    }
}

// ViewGroup 类的 drawChild 方法
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
    return child.draw(canvas, this, drawingTime);
}

在上述代码中，View 类的 draw 方法会依次调用 drawBackground、onDraw、dispatchDraw 和 onDrawForeground 方法。在 dispatchDraw 方法中，会遍历所有的子视图，并调用 drawChild 方法为每个子视图创建一个新的 Canvas 对象，然后调用子视图的 draw 方法进行绘制。

3.3 画笔（Paint）的初始化和使用

在使用 Canvas 进行绘图时，画笔（Paint）是一个非常重要的工具，它用于设置绘图的各种属性，如颜色、样式、字体等。以下是画笔的一些常用属性和方法：

import android.graphics.Paint;

// 创建一个新的画笔对象
Paint paint = new Paint();

// 设置画笔的颜色
paint.setColor(android.graphics.Color.RED);

// 设置画笔的样式，如填充、描边等
paint.setStyle(Paint.Style.FILL);

// 设置画笔的笔触宽度
paint.setStrokeWidth(5);

// 设置画笔的抗锯齿功能
paint.setAntiAlias(true);

// 设置字体大小
paint.setTextSize(20);

在上述代码中，我们创建了一个新的画笔对象，并设置了画笔的颜色、样式、笔触宽度、抗锯齿功能和字体大小等属性。

四、基本图形的绘制

4.1 绘制直线

使用 Canvas 的 drawLine 方法可以绘制直线。以下是一个绘制直线的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class LineView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public LineView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为蓝色
        mPaint.setColor(Color.BLUE);
        // 设置画笔的笔触宽度为 5
        mPaint.setStrokeWidth(5);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制一条从 (100, 100) 到 (200, 200) 的直线
        canvas.drawLine(100, 100, 200, 200, mPaint);
    }
}

在上述代码中，我们创建了一个自定义的 LineView 类，并重写了 onDraw 方法。在 onDraw 方法中，使用 Canvas 的 drawLine 方法绘制了一条从 (100, 100) 到 (200, 200) 的直线。

4.2 drawLine 方法的源码分析

// Canvas 类的 drawLine 方法
public void drawLine(float startX, float startY, float stopX, float stopY, @NonNull Paint paint) {
    // 调用 native 方法绘制直线
    native_drawLine(mNativeCanvasWrapper, startX, startY, stopX, stopY, paint.getNativeInstance());
}

在 Canvas 类的 drawLine 方法中，会调用 native_drawLine 方法来实现直线的绘制。native_drawLine 是一个本地方法，它会调用底层的图形库（如 Skia）来完成实际的绘制操作。

4.3 绘制矩形

使用 Canvas 的 drawRect 方法可以绘制矩形。以下是一个绘制矩形的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class RectView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public RectView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为绿色
        mPaint.setColor(Color.GREEN);
        // 设置画笔的样式为填充
        mPaint.setStyle(Paint.Style.FILL);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制一个左上角坐标为 (100, 100)，右下角坐标为 (200, 200) 的矩形
        canvas.drawRect(100, 100, 200, 200, mPaint);
    }
}

在上述代码中，我们创建了一个自定义的 RectView 类，并重写了 onDraw 方法。在 onDraw 方法中，使用 Canvas 的 drawRect 方法绘制了一个矩形。

4.4 drawRect 方法的源码分析

// Canvas 类的 drawRect 方法
public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) {
    // 调用 native 方法绘制矩形
    native_drawRect(mNativeCanvasWrapper, left, top, right, bottom, paint.getNativeInstance());
}

在 Canvas 类的 drawRect 方法中，会调用 native_drawRect 方法来实现矩形的绘制。native_drawRect 是一个本地方法，它会调用底层的图形库来完成实际的绘制操作。

4.5 绘制圆形

使用 Canvas 的 drawCircle 方法可以绘制圆形。以下是一个绘制圆形的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class CircleView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public CircleView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为黄色
        mPaint.setColor(Color.YELLOW);
        // 设置画笔的样式为填充
        mPaint.setStyle(Paint.Style.FILL);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制一个圆心坐标为 (150, 150)，半径为 50 的圆形
        canvas.drawCircle(150, 150, 50, mPaint);
    }
}

在上述代码中，我们创建了一个自定义的 CircleView 类，并重写了 onDraw 方法。在 onDraw 方法中，使用 Canvas 的 drawCircle 方法绘制了一个圆形。

4.6 drawCircle 方法的源码分析

// Canvas 类的 drawCircle 方法
public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint) {
    // 调用 native 方法绘制圆形
    native_drawCircle(mNativeCanvasWrapper, cx, cy, radius, paint.getNativeInstance());
}

在 Canvas 类的 drawCircle 方法中，会调用 native_drawCircle 方法来实现圆形的绘制。native_drawCircle 是一个本地方法，它会调用底层的图形库来完成实际的绘制操作。

五、文本和图像的绘制

5.1 绘制文本

使用 Canvas 的 drawText 方法可以绘制文本。以下是一个绘制文本的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class TextDrawView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public TextDrawView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为黑色
        mPaint.setColor(Color.BLACK);
        // 设置字体大小为 20
        mPaint.setTextSize(20);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制文本 "Hello, Canvas!"，起始坐标为 (100, 100)
        canvas.drawText("Hello, Canvas!", 100, 100, mPaint);
    }
}

在上述代码中，我们创建了一个自定义的 TextDrawView 类，并重写了 onDraw 方法。在 onDraw 方法中，使用 Canvas 的 drawText 方法绘制了一段文本。

5.2 drawText 方法的源码分析

// Canvas 类的 drawText 方法
public void drawText(@NonNull String text, float x, float y, @NonNull Paint paint) {
    // 调用 native 方法绘制文本
    native_drawText(mNativeCanvasWrapper, text, 0, text.length(), x, y, paint.getNativeInstance());
}

在 Canvas 类的 drawText 方法中，会调用 native_drawText 方法来实现文本的绘制。native_drawText 是一个本地方法，它会调用底层的图形库来完成实际的绘制操作。

5.3 绘制图像

使用 Canvas 的 drawBitmap 方法可以绘制图像。以下是一个绘制图像的示例：

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.view.View;

public class ImageDrawView extends View {
    // 定义位图对象
    private Bitmap mBitmap;

    public ImageDrawView(Context context) {
        super(context);
        // 加载位图资源
        mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.example_image);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制位图，起始坐标为 (100, 100)
        canvas.drawBitmap(mBitmap, 100, 100, null);
    }
}

在上述代码中，我们创建了一个自定义的 ImageDrawView 类，并重写了 onDraw 方法。在 onDraw 方法中，使用 Canvas 的 drawBitmap 方法绘制了一个位图。

5.4 drawBitmap 方法的源码分析

// Canvas 类的 drawBitmap 方法
public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) {
    // 调用 native 方法绘制位图
    native_drawBitmap(mNativeCanvasWrapper, bitmap, left, top, paint != null ? paint.getNativeInstance() : 0);
}

在 Canvas 类的 drawBitmap 方法中，会调用 native_drawBitmap 方法来实现位图的绘制。native_drawBitmap 是一个本地方法，它会调用底层的图形库来完成实际的绘制操作。

六、Canvas 的状态管理

6.1 保存和恢复状态

Canvas 提供了 save 和 restore 方法来保存和恢复 Canvas 的状态。在进行复杂的绘图操作时，我们可以先保存当前的 Canvas 状态，然后进行一些临时的变换和设置，最后再恢复到之前的状态。以下是一个示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class StateManagementView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public StateManagementView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为红色
        mPaint.setColor(Color.RED);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 保存当前的 Canvas 状态
        int saveCount = canvas.save();

        // 进行一些变换和设置
        canvas.translate(100, 100);
        mPaint.setColor(Color.BLUE);
        canvas.drawCircle(0, 0, 50, mPaint);

        // 恢复到之前的 Canvas 状态
        canvas.restoreToCount(saveCount);

        // 绘制一个红色的圆形
        mPaint.setColor(Color.RED);
        canvas.drawCircle(50, 50, 30, mPaint);
    }
}

在上述代码中，我们使用 canvas.save() 方法保存了当前的 Canvas 状态，然后进行了一些变换和设置，绘制了一个蓝色的圆形。最后，使用 canvas.restoreToCount(saveCount) 方法恢复到之前的状态，绘制了一个红色的圆形。

6.2 save 和 restore 方法的源码分析

// Canvas 类的 save 方法
public int save() {
    // 调用 native 方法保存 Canvas 状态
    return native_save(mNativeCanvasWrapper, SAVE_FLAG_FULL_COLOR_LAYER);
}

// Canvas 类的 restoreToCount 方法
public void restoreToCount(int saveCount) {
    // 调用 native 方法恢复 Canvas 状态
    native_restoreToCount(mNativeCanvasWrapper, saveCount);
}

在 Canvas 类的 save 方法中，会调用 native_save 方法保存当前的 Canvas 状态，并返回一个保存状态的标识符。在 restoreToCount 方法中，会调用 native_restoreToCount 方法根据保存状态的标识符恢复到之前的状态。

6.3 状态栈的管理

Canvas 的状态管理是通过一个状态栈来实现的。每次调用 save 方法时，会将当前的状态压入栈中；每次调用 restore 方法时，会从栈中弹出一个状态并恢复到之前的状态。以下是状态栈的简单示意图：

+-------------------+
|  状态 3           |
+-------------------+
|  状态 2           |
+-------------------+
|  状态 1           |
+-------------------+

在这个示意图中，状态 1 是最早保存的状态，状态 3 是最新保存的状态。每次调用 restore 方法时，会从栈顶弹出一个状态，直到栈为空。

七、Canvas 的变换操作

7.1 平移（Translate）

使用 Canvas 的 translate 方法可以对 Canvas 进行平移操作。平移操作会改变 Canvas 的坐标系原点位置。以下是一个平移操作的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class TranslateView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public TranslateView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为绿色
        mPaint.setColor(Color.GREEN);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 绘制一个圆形，圆心坐标为 (50, 50)
        canvas.drawCircle(50, 50, 20, mPaint);

        // 对 Canvas 进行平移操作，将坐标系原点向右移动 100 个单位，向下移动 100 个单位
        canvas.translate(100, 100);

        // 绘制一个圆形，圆心坐标为 (50, 50)，由于坐标系已经平移，实际位置会向右下方移动
        canvas.drawCircle(50, 50, 20, mPaint);
    }
}

在上述代码中，我们先绘制了一个圆形，然后使用 canvas.translate(100, 100) 方法对 Canvas 进行平移操作，最后再绘制一个圆形。由于坐标系已经平移，第二个圆形的实际位置会向右下方移动。

7.2 translate 方法的源码分析

// Canvas 类的 translate 方法
public void translate(float dx, float dy) {
    // 调用 native 方法进行平移操作
    native_translate(mNativeCanvasWrapper, dx, dy);
}

在 Canvas 类的 translate 方法中，会调用 native_translate 方法来实现平移操作。native_translate 是一个本地方法，它会调用底层的图形库来更新 Canvas 的坐标系。

7.3 旋转（Rotate）

使用 Canvas 的 rotate 方法可以对 Canvas 进行旋转操作。旋转操作会改变 Canvas 的坐标系方向。以下是一个旋转操作的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class RotateView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public RotateView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为蓝色
        mPaint.setColor(Color.BLUE);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 保存当前的 Canvas 状态
        int saveCount = canvas.save();

        // 将坐标系原点移动到 (100, 100)
        canvas.translate(100, 100);

        // 对 Canvas 进行旋转操作，旋转 45 度
        canvas.rotate(45);

        // 绘制一个矩形
        canvas.drawRect(-50, -50, 50, 50, mPaint);

        // 恢复到之前的 Canvas 状态
        canvas.restoreToCount(saveCount);
    }
}

在上述代码中，我们先保存了当前的 Canvas 状态，然后将坐标系原点移动到 (100, 100)，接着使用 canvas.rotate(45) 方法对 Canvas 进行旋转操作，最后绘制了一个矩形。由于坐标系已经旋转，矩形的方向也会发生改变。

7.4 rotate 方法的源码分析

// Canvas 类的 rotate 方法
public void rotate(float degrees) {
    // 调用 native 方法进行旋转操作
    native_rotate(mNativeCanvasWrapper, degrees);
}

在 Canvas 类的 rotate 方法中，会调用 native_rotate 方法来实现旋转操作。native_rotate 是一个本地方法，它会调用底层的图形库来更新 Canvas 的坐标系。

7.5 缩放（Scale）

使用 Canvas 的 scale 方法可以对 Canvas 进行缩放操作。缩放操作会改变 Canvas 的坐标系比例。以下是一个缩放操作的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;

public class ScaleView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public ScaleView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为黄色
        mPaint.setColor(Color.YELLOW);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 保存当前的 Canvas 状态
        int saveCount = canvas.save();

        // 将坐标系原点移动到 (100, 100)
        canvas.translate(100, 100);

        // 对 Canvas 进行缩放操作，在 X 轴和 Y 轴方向上都缩放为原来的 2 倍
        canvas.scale(2, 2);

        // 绘制一个圆形
        canvas.drawCircle(0, 0, 20, mPaint);

        // 恢复到之前的 Canvas 状态
        canvas.restoreToCount(saveCount);
    }
}

在上述代码中，我们先保存了当前的 Canvas 状态，然后将坐标系原点移动到 (100, 100)，接着使用 canvas.scale(2, 2) 方法对 Canvas 进行缩放操作，最后绘制了一个圆形。由于坐标系已经缩放，圆形的大小也会变为原来的 2 倍。

7.6 scale 方法的源码分析

// Canvas 类的 scale 方法
public void scale(float sx, float sy) {
    // 调用 native 方法进行缩放操作
    native_scale(mNativeCanvasWrapper, sx, sy);
}

在 Canvas 类的 scale 方法中，会调用 native_scale 方法来实现缩放操作。native_scale 是一个本地方法，它会调用底层的图形库来更新 Canvas 的坐标系。

八、Canvas 的裁剪操作

8.1 矩形裁剪

使用 Canvas 的 clipRect 方法可以对 Canvas 进行矩形裁剪操作。裁剪操作会限制后续绘图的范围。以下是一个矩形裁剪的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.view.View;

public class ClipRectView extends View {
    // 定义画笔对象
    private Paint mPaint;

    public ClipRectView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为红色
        mPaint.setColor(Color.RED);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 保存当前的 Canvas 状态
        int saveCount = canvas.save();

        // 定义一个矩形裁剪区域
        Rect clipRect = new Rect(100, 100, 200, 200);
        // 对 Canvas 进行矩形裁剪操作
        canvas.clipRect(clipRect);

        // 在裁剪区域内绘制一个圆形
        canvas.drawCircle(150, 150, 50, mPaint);

        // 恢复到之前的 Canvas 状态
        canvas.restoreToCount(saveCount);

        // 在未裁剪区域绘制一个矩形
        mPaint.setColor(Color.BLUE);
        canvas.drawRect(250, 250, 350, 350, mPaint);
    }
}

在上述代码中，我们先保存了当前的 Canvas 状态，然后定义了一个矩形裁剪区域，使用 canvas.clipRect(clipRect) 方法对 Canvas 进行裁剪操作，接着在裁剪区域内绘制了一个圆形。最后，恢复到之前的状态，在未裁剪区域绘制了一个矩形。

8.2 clipRect 方法的源码分析

// Canvas 类的 clipRect 方法
public boolean clipRect(@NonNull Rect rect) {
    // 调用 native 方法进行矩形裁剪操作
    return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, Region.Op.INTERSECT.nativeInt);
}

在 Canvas 类的 clipRect 方法中，会调用 native_clipRect 方法来实现矩形裁剪操作。native_clipRect 是一个本地方法，它会调用底层的图形库来更新 Canvas 的裁剪区域。

8.3 路径裁剪

使用 Canvas 的 clipPath 方法可以对 Canvas 进行路径裁剪操作。路径裁剪可以实现更复杂的裁剪效果。以下是一个路径裁剪的示例：

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.view.View;

public class ClipPathView extends View {
    // 定义画笔对象
    private Paint mPaint;
    // 定义路径对象
    private Path mPath;

    public ClipPathView(Context context) {
        super(context);
        // 初始化画笔
        initPaint();
        // 初始化路径
        initPath();
    }

    private void initPaint() {
        // 创建一个新的画笔对象
        mPaint = new Paint();
        // 设置画笔的颜色为绿色
        mPaint.setColor(Color.GREEN);
    }

    private void initPath() {
        // 创建一个新的路径对象
        mPath = new Path();
        // 移动到起始点
        mPath.moveTo(100, 100);
        // 绘制一条直线到 (200, 100)
        mPath.lineTo(200, 100);
        // 绘制一条直线到 (200, 200)
        mPath.lineTo(200, 200);
        // 绘制一条直线到 (100, 200)
        mPath.lineTo(100, 200);
        // 闭合路径
        mPath.close();
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 保存当前的 Canvas 状态
        int saveCount = canvas.save();

        // 对 Canvas 进行路径裁剪操作
        canvas.clipPath(mPath);

        // 在裁剪区域内绘制一个圆形
        canvas.drawCircle(150, 150, 50, mPaint);

        // 恢复到之前的 Canvas 状态
        canvas.restoreToCount(saveCount);

        // 在未裁剪区域绘制一个矩形
        mPaint.setColor(Color.BLUE);
        canvas.drawRect(250, 250, 350, 350, mPaint);
    }
}

在上述代码中，我们先保存了当前的 Canvas 状态，然后创建了一个路径对象，使用 canvas.clipPath(mPath) 方法对 Canvas 进行路径裁剪操作，接着在裁剪区域内绘制了一个圆形。最后，恢复到之前的状态，在未裁剪区域绘制了一个矩形。

8.4 clipPath 方法的源码分析

// Canvas 类的 clipPath 方法
public boolean clipPath(@NonNull Path path) {
    // 调用 native 方法进行路径裁剪操作
    return native_clipPath(mNativeCanvasWrapper, path.readOnlyNI(), Region.Op.INTERSECT.nativeInt);
}

在 Canvas 类的 clipPath 方法中，会调用 native_clipPath 方法来实现路径裁剪操作。native_clipPath 是一个本地方法，它会调用底层的图形库来更新 Canvas 的裁剪区域。

九、Canvas 的硬件加速

9.1 硬件加速的原理

Android 系统提供了硬件加速功能，它利用 GPU（图形处理单元）来加速图形的绘制过程。硬件加速可以显著提高绘图的性能，尤其是在绘制复杂图形和进行频繁的动画操作时。

硬件加速的基本原理是将绘图操作转换为 GPU 可以理解的指令，然后由 GPU 并行处理这些指令，从而加快绘图速度。在 Android 中，硬件加速是通过 OpenGL ES 来实现的。

9.2 开启和关闭硬件加速

在 Android 中，可以通过以下几种方式开启和关闭硬件加速：

• 应用级别 ：在 AndroidManifest.xml 文件中为应用设置 android:hardwareAccelerated="true" 来开启硬件加速，设置为 false 来关闭硬件加速。

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:hardwareAccelerated="true"
    android:theme="@style/AppTheme">
    ...
</application>

• Activity 级别 ：在 AndroidManifest.xml 文件中为 Activity 设置 android:hardwareAccelerated="true" 或 false 来开启或关闭硬件加速。

<activity
    android:name=".MainActivity"
    android:hardwareAccelerated="true">
    ...
</activity>

• View 级别 ：在代码中使用 setLayerType 方法为 View 设置硬件加速层类型。

view.setLayerType(View.LAYER_TYPE_HARDWARE, null); // 开启硬件加速
view.setLayerType(View.LAYER_TYPE_SOFTWARE, null); // 关闭硬件加速

9.3 硬件加速对 Canvas 的影响

在硬件加速开启的情况下，Canvas 的一些绘图操作会有不同的表现：

• 性能提升：由于 GPU 的并行处理能力，硬件加速可以显著提高绘图的性能，尤其是在绘制复杂图形和进行频繁的动画操作时。
• 部分操作受限：硬件加速不支持一些复杂的绘图操作，如自定义的 PathEffect、某些 PorterDuff 模式等。如果使用了这些不支持的操作，可能会导致绘图结果不正确或出现异常。
• 内存占用增加