[Android] View 的绘制流程不懂？来了解一下吧

最新推荐文章于 2024-05-08 18:19:13 发布
最新推荐文章于 2024-05-08 18:19:13 发布
阅读量764 收藏 29
点赞数 32
文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74863998/article/details/137105806
版权

《View 的绘制流程不懂？来了解一下吧》

前言

在 Android 开发中，View 的绘制是一个至关重要的环节，无论是简单的 TextView、Button 等，还是复杂的自定义控件，都需要经历一系列的绘制过程才能最终呈现在屏幕上。本文将从 View 的绘制整体流程到具体的绘制细节，由浅入深理解 View 的绘制流程。

1、View 显示到 Window 上的整体流程

View 添加到 Window 的起点是 ActivityThread 的 handleResumeActivity() 方法：

public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
        boolean isForward, boolean shouldSendCompatFakeFocus, String reason) {
        
    ......
    ......
    
    if (!performResumeActivity(r, finalStateRequest, reason)) {
        return;
    }
    
    ......
    ......
    
    if (r.window == null && !a.mFinished && willBeVisible) {
        r.window = r.activity.getWindow();
        View decor = r.window.getDecorView();
        decor.setVisibility(View.INVISIBLE);
        ViewManager wm = a.getWindowManager();
        WindowManager.LayoutParams l = r.window.getAttributes();
        a.mDecor = decor;
        l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
        l.softInputMode |= forwardBit;
        if (r.mPreserveWindow) {
            a.mWindowAdded = true;
            r.mPreserveWindow = false;
            ViewRootImpl impl = decor.getViewRootImpl();
            if (impl != null) {
                impl.notifyChildRebuilt();
            }
        }
        if (a.mVisibleFromClient) {
            if (!a.mWindowAdded) {
                a.mWindowAdded = true;
                wm.addView(decor, l);
            } else {
                a.onWindowAttributesChanged(l);
            }
        }
    } else if (!willBeVisible) {
        if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
        r.hideForNow = true;
    }

    ......
    ......
}

这里先调用了 performResumeActivity() 方法，获取记录了 activity 信息的对象并保存到传入的引用变量 ActivityClientRecord 中，也就是下面代码用到的 r 变量，如果获取失败就直接返回；随后调用 wm.addView(decor, l) 方法添加 decorView 和 WindowManager.LayoutParams，这里的 wm 就是根据 r 中记录的 activity 拿到对应的 WindowManagerImpl 对象，让我们看看 WindowManagerImpl 中的 addView() 方法：

public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyTokens(params);
    mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
            mContext.getUserId());
}

继续看 WindowManagerGlobal 中的 addView() 方法：

public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow, int userId) {
        
        ......
        ......
        
        mViews.add(view);
        mRoots.add(root);
        mParams.add(wparams);

        try {
            root.setView(view, wparams, panelParentView, userId);
        } catch (RuntimeException e) {
            final int viewIndex = (index >= 0) ? index : (mViews.size() - 1);
            if (viewIndex >= 0) {
                removeViewLocked(viewIndex, true);
            }
            throw e;
        }
        
        ......
        ......
}

这里先把 view,root,wparams 保存到 WindowManagerGlobal 内部的数组中，也就是：

private final ArrayList<View> mViews = new ArrayList<View>();
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
private final ArrayList<WindowManager.LayoutParams> mParams = new ArrayList<WindowManager.LayoutParams>();

WindowManagerGlobal 是用来全局管理 View 的类，因此这里要保存起来，随后调用 root.setView(view, wparams, panelParentView, userId) 方法将 View 添加到 root 中，root 即 ViewRootImpl，继续点进 setView() 中，其中调用了 request() 方法来请求布局：

public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

然后是 scheduleTraversals() 方法：

void scheduleTraversals() {
    if (!mTraversalScheduled) {
        mTraversalScheduled = true;
        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
        mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        notifyRendererOfFramePending();
        pokeDrawLockIfNeeded();
    }
}

其中的 mTraversalRunnable 是：

final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

final class TraversalRunnable implements Runnable {
    @Override
    public void run() {
        doTraversal();
    }
}

也就是这里又调用到了 doTraversal() 方法：

void doTraversal() {
    if (mTraversalScheduled) {
        mTraversalScheduled = false;
        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);

        if (mProfile) {
            Debug.startMethodTracing("ViewAncestor");
        }

        performTraversals();

        if (mProfile) {
            Debug.stopMethodTracing();
            mProfile = false;
        }
    }
}

最后通过 performTraversals() 方法执行 View 的具体绘制方法 。

流程总结： ActivityThread.handleResumeActivity() -> WindowManagerImpl.addView() -> WindowManagerGlobal.addView() -> ViewRootImpl.setView() -> ViewRootImpl.requestLayout() -> ViewRootImpl.scheduleTraversals() -> ViewRootImpl.doTraversal() -> ViewRootImpl.performTraversals()

2、ViewRootImpl 的 performTraversals() 方法中做了什么

在上面的流程介绍中，我们知道，最终调用 View 的方法进行真正的绘制是在 ViewRootImpl.performTraversals() 方法中，这个方法有多重要，从它的代码行数就能看出来，在 Android 34 的源码中，这个方法在 ViewRootImpl.java 的 2907 - 3845 行，整整 939 行。

由于代码量太大，这里就不把源码粘贴过来，有需要或者感兴趣的可以自己去看，接下来，我们将介绍 performTraversals() 方法里 5 个重要的步骤：

  1. 预测量：windowSizeMayChange |= measureHierarchy(host, lp, mView.getContext().getResources(), desiredWindowWidth, desiredWindowHeight, shouldOptimizeMeasure);
  2. 布局窗口：relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
  3. 控件树测量：performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
  4. 布局：performLayout(lp, mWidth, mHeight);
  5. 绘制：if (!performDraw() && mActiveSurfaceSyncGroup != null) { mActiveSurfaceSyncGroup.markSyncReady(); }

下面，让我们看看这些方法里面做了些什么。

1) 预测量 measureHierarchy()

private boolean measureHierarchy(final View host, final WindowManager.LayoutParams lp,
        final Resources res, final int desiredWindowWidth, final int desiredWindowHeight,
        boolean forRootSizeOnly) {
    int childWidthMeasureSpec;
    int childHeightMeasureSpec;
    boolean windowSizeMayChange = false;

    if (DEBUG_ORIENTATION || DEBUG_LAYOUT) Log.v(mTag,
            "Measuring " + host + " in display " + desiredWindowWidth
            + "x" + desiredWindowHeight + "...");

    boolean goodMeasure = false;
    if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) { // 1.
        final DisplayMetrics packageMetrics = res.getDisplayMetrics();
        res.getValue(com.android.internal.R.dimen.config_prefDialogWidth, mTmpValue, true); // 2.
        int baseSize = 0;
        if (mTmpValue.type == TypedValue.TYPE_DIMENSION) {
            baseSize = (int)mTmpValue.getDimension(packageMetrics); // 3.
        }
        if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": baseSize=" + baseSize
                + ", desiredWindowWidth=" + desiredWindowWidth);
        if (baseSize != 0 && desiredWindowWidth > baseSize) {
            childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width, lp.privateFlags);
            childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height,
                    lp.privateFlags);
            performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
            if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": measured ("
                    + host.getMeasuredWidth() + "," + host.getMeasuredHeight()
                    + ") from width spec: " + MeasureSpec.toString(childWidthMeasureSpec)
                    + " and height spec: " + MeasureSpec.toString(childHeightMeasureSpec));
            if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) { // 4.
                goodMeasure = true;
            } else {
                baseSize = (baseSize+desiredWindowWidth)/2; // 5.
                if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": next baseSize="
                        + baseSize);
                childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width, lp.privateFlags);
                performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
                if (DEBUG_DIALOG) Log.v(mTag, "Window " + mView + ": measured ("
                        + host.getMeasuredWidth() + "," + host.getMeasuredHeight() + ")");
                if ((host.getMeasuredWidthAndState()&View.MEASURED_STATE_TOO_SMALL) == 0) { // 6.
                    if (DEBUG_DIALOG) Log.v(mTag, "Good!");
                    goodMeasure = true;
                }
            }
        }
    }

    if (!goodMeasure) { // 7.
        childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width,
                lp.privateFlags);
        childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height,
                lp.privateFlags);
        if (!forRootSizeOnly || !setMeasuredRootSizeFromSpec(
                childWidthMeasureSpec, childHeightMeasureSpec)) {
            performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
        } else {
            mViewMeasureDeferred = true;
        }
        if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {
            windowSizeMayChange = true;
        }
    }

    if (DBG) {
        System.out.println("======================================");
        System.out.println("performTraversals -- after measure");
        host.debug();
    }

    return windowSizeMayChange;
}

上述代码按序号标记了主要的执行步骤，下面我们来一一分析：

  1. 判断父容器宽度是否设置为 WRAP_CONTENT，如果是，则进入 if 继续运行，否则直接跳到第 7 步；
  2. 获取一个系统默认的最小宽度，并保存到 mTmpValue 中，这个默认值为 320 dp，根据变量名 R.dimen.config_prefDialogWidth 就知道这是系统给 dialog 设置的默认最优宽度；
  3. 将第 2 步获取到的值赋给 baseSize，下面调用 performMeasure() 方法测量子 View 是否适合这个宽度，如果当前子 View 不适合 320 dp，则运行到第 4 步；
  4. 如果上面赋予的 320 dp 不合适，则进入到 else 执行第 5 步；
  5. 将 baseSize 根据当前屏幕宽度增大一定值，下面再次调用 performMeasure() 测量子 View，如果这步合适，则进行第 6 步，否则运行到第 7 步；
  6. 设置 goodMeasure 标志位为 true，则不会运行第 7 步；
  7. 运行到这里就直接将父容器能给的最大值赋给子 View，并判断父容器给子 View 的大小是否合适，不合适则 windowSizeMayChange = true，之后还将测量，若合适，则之后不再测量。

综上所述：如果如容器设置的宽度是 WRAP_CONTENT，则会至多进行三次 performMeasure()，如果其中有满足的则不会进入后面的 if 判断；设置的宽度不是 WRAP_CONTENT，则直接进入第 7 步，赋予父容器能给的最大值。

2) 布局窗口 relayoutWindow()

根据预测阶段量第 7 步中 windowSizeMayChange 的值，如果满足条件则会运行到 relayoutWindow() 方法，这个方法的主要工作包括：

  1. 计算窗口的尺寸和位置：根据窗口的布局参数和屏幕的尺寸，计算出窗口应该显示的位置和大小。
  2. 更新视图的布局参数：遍历窗口中的所有视图，根据它们的布局参数，更新它们的位置和大小。
  3. 执行视图的绘制：根据更新后的布局参数，重新绘制窗口中的所有视图。
  4. 更新窗口的显示状态：根据需要，更新窗口的显示状态，比如显示、隐藏或者改变透明度等。

因此我们知道：relayoutWindow() 方法是重新布局窗口的重要方法，它确保窗口中的所有视图都能按照最新的布局规则正确显示。

3) 控件树测量 performMeasure()

同样也是根据上文 windowSizeMayChange 的值，为 true 则会运行到 performMeasure() 方法再次进行测量。

这个方法就是进行了 View 的测量，调用链：ViewRootImpl.performMeasure() -> View.measure() -> View.onMeasure()

其中需要注意的点是，如果 View 重写了 onMeasure() 方法，则必须调用 setMeasureDimension() 方法（ super.onMeasure 也包括 ），因为在 View 的 measure() 方法的末尾有判断语句，若没调用 setMeasureDimension() 方法，则会报错，如下：

if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
    throw new IllegalStateException("View with id " + getId() + ": "
            + getClass().getName() + "#onMeasure() did not set the"
            + " measured dimension by calling"
            + " setMeasuredDimension()");
}

4) 布局控件树 performLayout()

这个方法比较简单，调用链：ViewRootImpl.performLayout() -> View.layout() -> View.onLayout()

而源码中的 View.onLayout() 方法为空，因为只有容器才需要布局子 View，我们知道 ViewGroup 是继承 View 的，而 ViewGroup.onLayout() 是抽象方法，因此继承 ViewGroup 自定义容器时，要重写 onLayout() 方法。

5) 绘制 performDraw()

这个方法也没什么好说的，调用链：ViewRootImpl.performDraw() -> ViewRootImpl.draw() -> 硬件加速 或 软件绘制

其中在 ViewRootImpl.draw() 中会判断是 硬件加速 还是 软件绘制，源码如下：

if (isHardwareEnabled()) {
    ......
    ......
    mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
} else {
    ......
    ......
    if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty, surfaceInsets)) {
        return false;
    }
}

这里的 硬件加速 和 软件绘制，感兴趣的读者可以自行搜索了解。

3、requestLayout() 和 invalidate() 的区别

我们知道调用 requestLayout() 或 invalidate() 方法都会重新绘制 View，那么这两者有什么区别呢？答案是 requestLayout() 方法会重新测量、布局并绘制，而 invalidate() 方法则是直接到绘制阶段。具体流程如下图所示：

View 的绘制流程.jpg

👉 以上就是对 View 绘制流程的简单梳理。

imHuSY
关注
  • 32
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android View 绘制流程(Draw)全面解析
01-20
测量流程决定了View的大小，布局流程决定了View的位置，那么绘制流程将决定View的样子，一个View该显示什么由绘制流程完成。以下源码均取自Android API 21。 从performDraw说起 前面几篇文章提到，三大工作流程始于...
深入理解Android中View绘制的三大流程
08-29
主要给大家介绍了关于Android中View绘制的三大流程，View的工作流程主要是指measure、layout、draw这三大流程，即测量、布局和绘制，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们...
Android源码：View是如何绘制到屏幕上的？
m0_62167422的博客
05-07 773
前言 在Android中如果要显示一个页面，那么只需要在Activity的onCreate()方法中，把我们写好的页面布局layout传入到setContentView()方法中即可，这样Activity就会完成接下来的工作，通过一系列的操作把我们想要的布局页面显示出来，不需要我们再做任何的处理，所以最初的时候一直以为是Activity将layout布局中的控件绘制出来的，但事实究竟是怎样的呢，我们来一探究竟。 首先，我们都知道在onCreate()方法中调用setContentView()函数，Activ
Android之View的绘制流程
weixin_30385925的博客
03-24 103
本篇文章会从源码（基于Android 6.0）角度分析Android中View的绘制流程，侧重于对整体流程的分析，对一些难以理解的点加以重点阐述，目的是把View绘制的整个流程把握好，而对于特定实现细节则可以日后再对相应源码进行研读。 在进行实际的分析之前，我们先来看下面这张图： ...
面试 100% 完全掌握：重新认识 View 的绘制流程(1)
最新发布
2401_84149814的博客
05-08 878
流程图分析了解view绘制流程了解如何附加到内容到页面关键类解释=====一. 流程图分析========1.1 创建Activity到setContentView的窗口附加流程图下图展示了window的创建到之后的窗体view树变化情况activity 设置布局流程1.2 view绘制流程图绘制流程图二. view绘制流程===========2.1 绘制流程分析在我们调用 和 的时候，我们会让view刷新布局和绘制。所以从这两个方法入手，可以完整地走一遍绘制流程。 绘制动画等行为主要通过 类协调。调用
Android知识架构 · 电话面试 · View的绘制流程
carter_yu的博客
09-12 5248
View的绘制流程：OnMeasure()——>OnLayout()——>OnDraw()各步骤的主要工作： OnMeasure()：测量视图大小。从顶层父View到子View递归调用measure方法，measure方法又回调OnMeasure。 OnLayout()：确定View位置，进行页面布局。从顶层父View向子View的递归调用view.layout方法的过程，即父View根据上一步me
View的绘制流程
weixin_42446445的博客
03-16 117
获取Windows对象，Window是一个抽象类，在Android实现中目前只有一个实现类，PhoneWindow，在我们的Activity中调用setContentView其实调用的PhoneWindow对象的setContentView方法。 在PhoneWindow中的setContentView中调用了installDecor方法，在installDecor方法中调用了genera...
浅谈Android View绘制三大流程探索及常见问题
08-31
下面小编就为大家带来一篇浅谈Android View绘制三大流程探索及常见问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【view的绘制流程】
徐明晓的博客
05-23 291
https://blog.csdn.net/sinat_27154507/article/details/79748010 https://www.jianshu.com/p/5a71014e7b1b [1] Measure过程 对于测量我们来说几个知识点,了解这几个知识点，之后的实例分析你才看得懂。 1、MeasureSpec 的理解 对于View的测量，肯定会和MeasureSpec接触，MeasureSpec是两个单词组成，翻译过来“测量规格”或者“测量参数”，很多博客包括官方文档对他的说明基本.
View绘制流程
xHai的博客
12-28 1737
绘制优化一、绘制原理二、性能分析工具 android需将自己的界面展示给用户，用户和界面进行交互，流畅度就非常重要！此处我们将学习绘制性能分析，首先学习绘制原理，接下来学习性能分析工具。 一、绘制原理 View的绘制流程有3个步骤： measure layout draw 它们主要运行在系统的应用框架层，而真正将数据渲染到屏幕上的则是系统Native层的SurfaceFlinger服务来完成的。 绘制过程主要由CPU来进行Measure、Layout、Record、Execute的数据计算工作，GPU负
说说View的绘制流程（一）
Johnnie Zhang的专栏
05-31 1603
在我们的Android项目开发过程中，相信大家肯定会涉及到对View流程绘制的相关开发（比如：自定义控件）。本文试着从源码（Android 10，我们之所以选择API 10源码，是为了尽量减少一些主题无关的复杂性，便于理解和阅读）角度，，试着总结下关于View的绘制流程。 说起View的绘制过程，本文从Activity的创建过程开始到View被触发绘制流程。我们知道，当用户启动一个Activity时（比如通过startActivity调用），AMS（Activity Manager Service）
Android View的绘制流程
这都是什么
06-17 401
View的绘制流程 源码分析： 1.绘制入口 ActivityThread.handleResumeActivity -->WindowManagerImpl.addView(decorView,layoutParams) -->WindowManagerGlobal.addView() 2.绘制类以及方法 ViewRootImpl.setView(decorView...
android中view的绘制流程及performtraversal
03-16
Android中View的绘制流程是指从View的根节点开始，递归遍历所有子节点，对每个节点进行测量、布局和绘制的过程。具体流程如下： 1.测量(Measure)：在View的onMeasure()方法中进行，测量View的宽高以及子View的宽高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值