皮皮网

1.android开发设置屏蔽录制
2.Android UI绘制之View绘制的工作原理
3.Android 14 HWUI 源码研究 View Canvas RenderThread ViewRootImpl skia
4.setContentView()及LayoutInflater布局加载源码分析

android开发设置屏蔽录制

       é¡¹ç›®å¼€å‘中，为了用户信息的安全，会有禁止页面被截屏、录屏的需求。

       è¿™ç±»èµ„料，在网上有很多，一般都是通过设置Activity的Flag解决，如：

       //禁止页面被截屏、录屏getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);

       è¿™ç§è®¾ç½®å¯è§£å†³ä¸€èˆ¬çš„防截屏、录屏的需求。

       å¦‚果页面中有弹出Popupwindow，在录屏视频中的效果是：

       éžPopupwindow区域为黑色

       ä½†Popupwindow区域仍然是可以看到的

       å¦‚下面两张Gif图所示：

       æœªè®¾ç½®FLAG_SECURE，录屏的效果，如下图（git图片中间的水印忽略）：

       è®¾ç½®äº†FLAG_SECURE之后，录屏的效果，如下图（git图片中间的水印忽略）：

       åŽŸå› åˆ†æž

       çœ‹åˆ°äº†ä¸Šé¢çš„效果，我们可能会有疑问PopupWindow不像Dialog有自己的window对象，而是使用WindowManager.addView方法将View显示在Activity窗体上的。那么，Activity已经设置了FLAG_SECURE，为什么录屏时还能看到PopupWindow？

       æˆ‘们先通过getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);来分析下源码：

       1、Window.java

       //window布局参数private final WindowManager.LayoutParams mWindowAttributes =        new WindowManager.LayoutParams();//添加标识public void addFlags(int flags) {

       setFlags(flags, flags);

       }//通过mWindowAttributes设置标识public void setFlags(int flags, int mask) {        final WindowManager.LayoutParams attrs = getAttributes();

       attrs.flags = (attrs.flags&~mask) | (flags&mask);

       mForcedWindowFlags |= mask;

       dispatchWindowAttributesChanged(attrs);

       }//获得布局参数对象，即mWindowAttributespublic final WindowManager.LayoutParams getAttributes() {        return mWindowAttributes;

       }

       é€šè¿‡æºç å¯ä»¥çœ‹åˆ°ï¼Œè®¾ç½®window属性的源码非常简单，即：通过window里的布局参数对象mWindowAttributes设置标识即可。

       2、PopupWindow.java

       //显示PopupWindowpublic void showAtLocation(View parent, int gravity, int x, int y) {

       mParentRootView = new WeakReference<>(parent.getRootView());

       showAtLocation(parent.getWindowToken(), gravity, x, y);

       }//显示PopupWindowpublic void showAtLocation(IBinder token, int gravity, int x, int y) {        if (isShowing() || mContentView == null) {            return;

       }

       TransitionManager.endTransitions(mDecorView);

       detachFromAnchor();

       mIsShowing = true;

       mIsDropdown = false;

       mGravity = gravity;

       //创建Window布局参数对象

       final WindowManager.LayoutParams p =createPopupLayoutParams(token);

       preparePopup(p);

       p.x = x;

       p.y = y;

       invokePopup(p);

       }//创建Window布局参数对象protected final WindowManager.LayoutParams createPopupLayoutParams(IBinder token) {        final WindowManager.LayoutParams p = new WindowManager.LayoutParams();

       p.gravity = computeGravity();

       p.flags = computeFlags(p.flags);

       p.type = mWindowLayoutType;

       p.token = token;

       p.softInputMode = mSoftInputMode;

       p.windowAnimations = computeAnimationResource();        if (mBackground != null) {

       p.format = mBackground.getOpacity();

       } else {

       p.format = PixelFormat.TRANSLUCENT;

       }        if (mHeightMode < 0) {

       p.height = mLastHeight = mHeightMode;

       } else {

       p.height = mLastHeight = mHeight;

       }        if (mWidthMode < 0) {

       p.width = mLastWidth = mWidthMode;

       } else {

       p.width = mLastWidth = mWidth;

       }

       p.privateFlags = PRIVATE_FLAG_WILL_NOT_REPLACE_ON_RELAUNCH

       | PRIVATE_FLAG_LAYOUT_CHILD_WINDOW_IN_PARENT_FRAME;

       p.setTitle("PopupWindow:" + Integer.toHexString(hashCode()));        return p;

       }//将PopupWindow添加到Window上private void invokePopup(WindowManager.LayoutParams p) {        if (mContext != null) {

       p.packageName = mContext.getPackageName();

       }        final PopupDecorView decorView = mDecorView;

       decorView.setFitsSystemWindows(mLayoutInsetDecor);

       setLayoutDirectionFromAnchor();

       mWindowManager.addView(decorView, p);        if (mEnterTransition != null) {

       decorView.requestEnterTransition(mEnterTransition);

       }

       }

       é€šè¿‡PopupWindow的源码分析，我们不难看出，在调用showAtLocation时，会单独创建一个WindowManager.LayoutParams布局参数对象，用于显示PopupWindow，而该布局参数对象上并未设置任何防止截屏Flag。

       å¦‚何解决

       åŽŸå› æ—¢ç„¶æ‰¾åˆ°äº†ï¼Œé‚£ä¹ˆå¦‚何处理呢？

       å†å›žå¤´åˆ†æžä¸‹Window的关键代码：

       //通过mWindowAttributes设置标识public void setFlags(int flags, int mask) {        final WindowManager.LayoutParams attrs = getAttributes();

       attrs.flags = (attrs.flags&~mask) | (flags&mask);

       mForcedWindowFlags |= mask;

       dispatchWindowAttributesChanged(attrs);

       }

       å…¶å®žåªéœ€è¦èŽ·å¾—WindowManager.LayoutParams对象，再设置上flag即可。

       ä½†æ˜¯PopupWindow并没有像Activity一样有直接获得window的方法，更别说设置Flag了。我们再分析下PopupWindow的源码：

       //将PopupWindow添加到Window上private void invokePopup(WindowManager.LayoutParams p) {        if (mContext != null) {

       p.packageName = mContext.getPackageName();

       }

       final PopupDecorView decorView = mDecorView;

       decorView.setFitsSystemWindows(mLayoutInsetDecor);

       setLayoutDirectionFromAnchor();        //添加View

       mWindowManager.addView(decorView, p);        if (mEnterTransition != null) {

       decorView.requestEnterTransition(mEnterTransition);

       }

       }

       æˆ‘们调用showAtLocation，最终都会执行mWindowManager.addView(decorView, p);

       é‚£ä¹ˆæ˜¯å¦å¯ä»¥åœ¨addView之前获取到WindowManager.LayoutParams呢？

       ç­”案很明显，默认是不可以的。因为PopupWindow并没有公开获取WindowManager.LayoutParams的方法，而且mWindowManager也是私有的。

       å¦‚何才能解决呢？

       æˆ‘们可以通过hook的方式解决这个问题。我们先使用动态代理拦截PopupWindow类的addView方法，拿到WindowManager.LayoutParams对象，设置对应Flag，再反射获得mWindowManager对象去执行addView方法。

       é£Žé™©åˆ†æžï¼š

       ä¸è¿‡ï¼Œé€šè¿‡hook的方式也有一定的风险，因为mWindowManager是私有对象，不像Public的API，谷歌后续升级Android版本不会考虑其兼容性，所以有可能后续Android版本中改了其名称，那么我们通过反射获得mWindowManager对象不就有问题了。不过从历代版本的Android源码去看，mWindowManager被改的几率不大，所以hook也是可以用的，我们尽量写代码时考虑上这种风险，避免以后出问题。

       public class PopupWindow {

       ......    private WindowManager mWindowManager;

       ......

       }

       è€ŒaddView方法是ViewManger接口的公共方法，我们可以放心使用。

       public interface ViewManager{    public void addView(View view, ViewGroup.LayoutParams params);    public void updateViewLayout(View view, ViewGroup.LayoutParams params);    public void removeView(View view);

       }

       åŠŸèƒ½å®žçŽ°

       è€ƒè™‘到hook的可维护性和扩展性，我们将相关代码封装成一个独立的工具类吧。

       package com.ccc.ddd.testpopupwindow.utils;

       import android.os.Handler;

       import android.view.WindowManager;

       import android.widget.PopupWindow;

       import java.lang.reflect.Field;

       import java.lang.reflect.InvocationHandler;

       import java.lang.reflect.Method;

       import java.lang.reflect.Proxy;public class PopNoRecordProxy implements InvocationHandler {    private Object mWindowManager;//PopupWindow类的mWindowManager对象

       public static PopNoRecordProxy instance() {        return new PopNoRecordProxy();

       }    public void noScreenRecord(PopupWindow popupWindow) {        if (popupWindow == null) {            return;

       }        try {            //通过反射获得PopupWindow类的私有对象：mWindowManager

       Field windowManagerField = PopupWindow.class.getDeclaredField("mWindowManager");

       windowManagerField.setAccessible(true);

       mWindowManager = windowManagerField.get(popupWindow);            if(mWindowManager == null){                return;

       }            //创建WindowManager的动态代理对象proxy

       Object proxy = Proxy.newProxyInstance(Handler.class.getClassLoader(), new Class[]{ WindowManager.class}, this);            //注入动态代理对象proxy（即：mWindowManager对象由proxy对象来代理）

       windowManagerField.set(popupWindow, proxy);

       } catch (IllegalAccessException e) {

       e.printStackTrace();

       } catch (NoSuchFieldException e) {

       e.printStackTrace();

       }

       }

       @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        try {            //拦截方法mWindowManager.addView(View view, ViewGroup.LayoutParams params);

       if (method != null && method.getName() != null && method.getName().equals("addView")

       && args != null && args.length == 2) {                //获取WindowManager.LayoutParams，即：ViewGroup.LayoutParams

       WindowManager.LayoutParams params = (WindowManager.LayoutParams) args[1];                //禁止录屏

       setNoScreenRecord(params);

       }

       } catch (Exception ex) {

       ex.printStackTrace();

       }        return method.invoke(mWindowManager, args);

       }    /

**

       * 禁止录屏

       */

       private void setNoScreenRecord(WindowManager.LayoutParams params) {

       setFlags(params, WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE);

       }    /

**

       * 允许录屏

       */

       private void setAllowScreenRecord(WindowManager.LayoutParams params) {

       setFlags(params, 0, WindowManager.LayoutParams.FLAG_SECURE);

       }    /

**

       * 设置WindowManager.LayoutParams flag属性（参考系统类Window.setFlags(int flags, int mask)）

       

*

       * @param params WindowManager.LayoutParams

       * @param flags  The new window flags (see WindowManager.LayoutParams).

       * @param mask   Which of the window flag bits to modify.

       */

       private void setFlags(WindowManager.LayoutParams params, int flags, int mask) {        try {            if (params == null) {                return;

       }            params.flags = (params.flags & ~mask) | (flags & mask);

       } catch (Exception ex) {

       ex.printStackTrace();

       }

       }

       }

       Popwindow禁止录屏工具类的使用，代码示例：

          //创建PopupWindow

       //正常项目中，该方法可改成工厂类

       //正常项目中，也可自定义PopupWindow，在其类中设置禁止录屏

       private PopupWindow createPopupWindow(View view, int width, int height) {

       PopupWindow popupWindow = new PopupWindow(view, width, height);        //PopupWindow禁止录屏

       PopNoRecordProxy.instance().noScreenRecord(popupWindow);        return popupWindow;

       }   //显示Popupwindow

       private void showPm() {

       View view = LayoutInflater.from(this).inflate(R.layout.pm1, null);

       PopupWindow  pw = createPopupWindow(view,ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);

       pw1.setFocusable(false);

       pw1.showAtLocation(this.getWindow().getDecorView(), Gravity.BOTTOM | Gravity.RIGHT, PopConst.PopOffsetX, PopConst.PopOffsetY);

       }

       å½•å±æ•ˆæžœå›¾ï¼š

Android UI绘制之View绘制的工作原理

        这是AndroidUI绘制流程分析的第二篇文章，主要分析界面中View是如何绘制到界面上的具体过程。

        ViewRoot 对应于 ViewRootImpl 类，它是连接 WindowManager 和 DecorView 的纽带，View的三大流程均是通过 ViewRoot 来完成的。在 ActivityThread 中，当 Activity 对象被创建完毕后，会将 DecorView 添加到 Window 中,同时会创建 ViewRootImpl 对象，并将 ViewRootImpl 对象和 DecorView 建立关联。

        measure 过程决定了 View 的宽/高， Measure 完成以后，可以通过 getMeasuredWidth 和 getMeasuredHeight 方法来获取 View 测量后的宽/高，在几乎所有的情况下，它等同于View的最终的宽/高，但是特殊情况除外。 Layout 过程决定了 View 的四个顶点的坐标和实际的宽/高，完成以后，可以通过 getTop、getBottom、getLeft 和 getRight 来拿到View的四个顶点的位置，可以通过 getWidth 和 getHeight 方法拿到View的最终宽/高。 Draw 过程决定了 View 的显示，只有 draw 方法完成后 View 的内容才能呈现在屏幕上。

        DecorView 作为顶级 View ，一般情况下，它内部会包含一个竖直方向的 LinearLayout ，在这个 LinearLayout 里面有上下两个部分，上面是标题栏，下面是内容栏。在Activity中，我们通过 setContentView 所设置的布局文件其实就是被加到内容栏中的，而内容栏id为 content 。可以通过下面方法得到 content:ViewGroup content = findViewById(R.android.id.content) 。通过 content.getChildAt(0) 可以得到设置的 view 。 DecorView 其实是一个 FrameLayout , View 层的事件都先经过 DecorView ，然后才传递给我们的 View 。

        MeasureSpec 代表一个位的int值，高2位代表 SpecMode ,低位代表 SpecSize , SpecMode 是指测量模式，而 SpecSize 是指在某种测量模式下的规格大小。

        SpecMode 有三类，如下所示：

        UNSPECIFIED

        EXACTLY

        AT_MOST

        LayoutParams需要和父容器一起才能决定View的MeasureSpec，从而进一步决定View的宽/高。

        对于顶级View，即DecorView和普通View来说，MeasureSpec的转换过程略有不同。对于DecorView，其MeasureSpec由窗口的尺寸和其自身的LayoutParams共同确定；

        对于普通View，其MeasureSpec由父容器的MeasureSpec和自身的Layoutparams共同决定；

        MeasureSpec一旦确定，onMeasure就可以确定View的测量宽/高。

        小结一下

        当子 View 的宽高采用 wrap_content 时，不管父容器的模式是精确模式还是最大模式，子 View 的模式总是最大模式+父容器的剩余空间。

        View 的工作流程主要是指 measure 、 layout 、 draw 三大流程，即测量、布局、绘制。其中 measure 确定 View 的测量宽/高， layout 确定 view 的最终宽/高和四个顶点的位置，而 draw 则将 View 绘制在屏幕上。

        measure 过程要分情况，如果只是一个原始的 view ，则通过 measure 方法就完成了其测量过程，如果是一个 ViewGroup ，除了完成自己的测量过程外，还会遍历调用所有子元素的 measure 方法，各个子元素再递归去执行这个流程。

        如果是一个原始的 View，那么通过 measure 方法就完成了测量过程，在 measure 方法中会去调用 View 的 onMeasure 方法，View 类里面定义了 onMeasure 方法的默认实现:

        先看一下 getSuggestedMinimumWidth 和 getSuggestedMinimumHeight 方法的源码：

        可以看到， getMinimumWidth 方法获取的是 Drawable 的原始宽度。如果存在原始宽度（即满足 intrinsicWidth > 0），那么直接返回原始宽度即可；如果不存在原始宽度（即不满足 intrinsicWidth > 0），那么就返回 0。

        接着看最重要的 getDefaultSize 方法：

        如果 specMode 为 MeasureSpec.UNSPECIFIED 即未指定模式，那么返回由方法参数传递过来的尺寸作为 View 的测量宽度和高度；

        如果 specMode 不是 MeasureSpec.UNSPECIFIED 即是最大模式或者精确模式，那么返回从 measureSpec 中取出的 specSize 作为 View 测量后的宽度和高度。

        看一下刚才的表格：

        当 specMode 为 EXACTLY 或者 AT_MOST 时，View 的布局参数为 wrap_content 或者 match_parent 时，给 View 的 specSize 都是 parentSize 。这会比建议的最小宽高要大。这是不符合我们的预期的。因为我们给 View 设置 wrap_content 是希望View的大小刚好可以包裹它的内容。

        因此：

        如果是一个 ViewGroup，除了完成自己的 measure 过程以外，还会遍历去调用所有子元素的 measure 方法，各个子元素再递归去执行 measure 过程。

        ViewGroup 并没有重写 View 的 onMeasure 方法，但是它提供了 measureChildren、measureChild、measureChildWithMargins 这几个方法专门用于测量子元素。

        如果是 View 的话，那么在它的 layout 方法中就确定了自身的位置（具体来说是通过 setFrame 方法来设定 View 的四个顶点的位置，即初始化 mLeft ， mRight ， mTop ， mBottom 这四个值）， layout 过程就结束了。

        如果是 ViewGroup 的话，那么在它的 layout 方法中只是确定了 ViewGroup 自身的位置，要确定子元素的位置，就需要重写 onLayout 方法；在 onLayout 方法中，会调用子元素的 layout 方法，子元素在它的 layout 方法中确定自己的位置，这样一层一层地传递下去完成整个 View 树的 layout 过程。

        layout 方法的作用是确定 View 本身的位置，即设定 View 的四个顶点的位置，这样就确定了 View 在父容器中的位置；

        onLayout 方法的作用是父容器确定子元素的位置，这个方法在 View 中是空实现，因为 View 没有子元素了，在 ViewGroup 中则进行抽象化，它的子类必须实现这个方法。

        1.绘制背景（ background.draw(canvas); ）；

        2.绘制自己（ onDraw ）；

        3.绘制 children（ dispatchDraw(canvas) ）；

        4.绘制装饰（ onDrawScrollBars ）。

        dispatchDraw 方法的调用是在 onDraw 方法之后，也就是说，总是先绘制自己再绘制子 View 。

        对于 View 类来说， dispatchDraw 方法是空实现的，对于 ViewGroup 类来说， dispatchDraw 方法是有具体实现的。

        通过 dispatchDraw 来传递的。 dispatchDraw 会遍历调用子元素的 draw 方法，如此 draw 事件就一层一层传递了下去。dispatchDraw 在 View 类中是空实现的，在 ViewGroup 类中是真正实现的。

        如果一个 View 不需要绘制任何内容，那么就设置这个标记为 true，系统会进行进一步的优化。

        当创建的自定义控件继承于 ViewGroup 并且不具备绘制功能时，就可以开启这个标记，便于系统进行后续的优化；当明确知道一个 ViewGroup 需要通过 onDraw 绘制内容时，需要关闭这个标记。

        参考：《Android开发艺术探索》

Android HWUI 源码研究 View Canvas RenderThread ViewRootImpl skia

       HUWUI是Android系统中负责应用可视化元素绘制的核心组件，其架构主要在C++层实现，从Java层接收View绘制信息，通过唯一的渲染线程使用skia技术完成渲染任务。整体上，从应用程序到UI线程，支付源码交易再到渲染线程，形成了清晰的层级关系。

       HUWUI的构建主要包括三个核心类，它们分别是：RecordingCanvas、Canvas、RenderNode、nft抢购源码CRenderProxy、RenderThread、CanvasContext、IRenderPipeline。在Java层，主要涉及两类Canvas，RecordingCanvas用于记录绘制指令，Canvas则是直接用于渲染。RecordingCanvas在构造时创建，而Canvas在调用时创建。这两个类在C++层分别对应SkiaRecordingCanvas和SkiaCanvas，谷歌站群源码后者直接引用SkCanvas。

       在全局循环中，UI线程与渲染线程之间的协同操作至关重要。具体流程包括：新创建Activity后，附着到对应的PhoneWindow，然后调用PhoneWindow的setContentView方法，将View添加到DecorView作为子节点。接着，DecorView与ViewRootImpl对接，完成View的更新与渲染。整个过程包含了measure、合从源码下载layout和draw等复杂子流程。

       渲染线程创建与核心对象紧密关联，主要包括RenderProxy、RenderThread和DrawFrameTask。RenderProxy负责Java层信息的衔接，RenderThread作为进程唯一的渲染线程，持有DrawFrameTask和CanvasContext，完成一帧的绘制任务。指令记录流程的核心在于使用C++层的RecordingCanvas将View属性和绘制信息记录到DisplayList中，进而完成指令的渲染。

       Surface、可爱单网页源码ANativeWindow、EGLSurface的创建流程在ViewRootImpl的performTraversals函数中初始化。ReliableSurface的封装和EGL与Skia环境的创建主要在RenderThread的requireGlContext函数中实现。从源码分析，这一过程通常在三个地方调用。

       View树与RenderNode树之间的协作关系明确，一个Application进程对应多个Activity，每个Activity与一个PhoneWindow绑定，PhoneWindow持有DecorView，DecorView对应一个ViewRootImpl，而ViewRootImpl与ThreadedRender模块对接。ThreadedRender与C++层的RenderProxy一一对应，RenderProxy持有关键对象，如RenderThread、CanvasContext、DrawFrameTask等。RenderThread是单例模式，进程唯一，负责一帧绘制的逻辑。

       在RenderPipeline模块中，关键操作包括makeCurrent、draw和swapBuffers。Native Canvas在这一过程中扮演了桥梁角色，接收Java API调用，而RecordingCanvas完成Op记录，最终DisplayListData存储这些Op。

       skia的核心资源主要在三个使用场景中发挥作用，具体细节需深入分析，这些资源对于实现高效、稳定的渲染效果至关重要。

setContentView()及LayoutInflater布局加载源码分析

       setContentView()和LayoutInflater布局加载源码深度解析

       当我们在Android应用中调用setContentView()时，其实涉及到了一系列复杂的流程。这个过程主要分为三个步骤：系统布局加载、LayoutInflater初始化以及LayoutInflater布局加载。

       首先，setContentView()方法通过Activity的PhoneWindow对象加载布局。在判断mContentParent是否为空后，会创建DecorView，然后将自定义的activity_main_layout加载到mContentParent，这个mContentParent对应id为R.id.content的Layout。接着，系统会加载一个包含R.id.content的系统布局到DecorView中。

       LayoutInflater的初始化过程关键在于其作为系统服务注册在SystemServiceRegistry中。当我们通过LayoutInflater.from(this)获取实例时，实际上是通过SystemServiceRegistry获取并初始化LayoutInflater的。

       LayoutInflater的布局加载流程则涉及xml预编译、View的反射创建以及递归解析子布局。在inflate方法中，会先检查根节点标签是否为"merge"，然后决定是否递归加载子布局并决定是否添加到父布局中。View的创建则可能通过自定义的Factory进行拦截和定制。

       总结来说，setContentView()和LayoutInflater的交互使得我们能够灵活地加载和定制Activity的布局。通过理解这些源码细节，开发者可以更好地控制和优化应用的界面显示。