View的工作原理阅读笔记

初识ViewRoot和DecorView
- DecorView的结构
Measure过程
- MeaureSpec
- - MeaureSpec的含义
  - SpecMode 的类型
  - MeasureSpec 和 LayoutParams 的对应关系
- LinearLayout Measure 示例
- 获取view宽高的时机
layout过程
draw过程
自定义view注意事项

初识ViewRoot和DecorView

ViewRoot:

联系windowManager和Decorview的纽带，View的三大流程均通过ViewRoot完成

DecorView:

是Activity的顶级view。内部通常包含一个LinearLayout.

在ActivityThread的ApplicationThread中，在完成activity的创建后，会调用方法handleResumeActivity，去完成onresume的调用。在handleResumeActivity方法中

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume) {
            //...
            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 (a.mVisibleFromClient) {
                    a.mWindowAdded = true;
                    //将decorView添加到windowManager
                    wm.addView(decor, l);
                }
            } 
            //...
    }

这里的windowManager的具体实现者是WindowManagerImpl。所以我们来看WindowManagerImpl的addView。

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mDisplay, mParentWindow);
    }

这里调用了WindowManagerGlobal的addview

public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
      	//...
        synchronized (mLock) {
           //....
           //这里就是书上的源码了，将viewrootimpl和decorview建立关联
            root = new ViewRootImpl(view.getContext(), display);
            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);
        }

        // do this last because it fires off messages to start doing things
        root.setView(view, wparams, panelParentView);
		//..
    }

DecorView的结构

DecorView继承自FrameLayout。一般来讲内部包含一个LinearLayout。

而这个LinearLayout是在PhoneWindow初始化DecorView的时候，在generateLayout方法中添加的。

protected ViewGroup generateLayout(DecorView decor) {
         int layoutResource;
        int features = getLocalFeatures();
        // System.out.println("Features: 0x" + Integer.toHexString(features));
        if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
          //...这里省略了若干判断分支,根据主题不同加载不同的布局
        } else {
            // Embedded, so no decoration is needed.
            //如果使用NoActionBar主题，一般默认加载这个布局。
            layoutResource = R.layout.screen_simple;
            // System.out.println("Simple!");
        }
         View in = mLayoutInflater.inflate(layoutResource, null);
        decor.addView(in, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
  }

而screen_simple的默认布局就是这样

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true"
    android:orientation="vertical">
    <ViewStub android:id="@+id/action_mode_bar_stub"
              android:inflatedId="@+id/action_mode_bar"
              android:layout="@layout/action_mode_bar"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:theme="?attr/actionBarTheme" />
    <FrameLayout
         android:id="@android:id/content"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:foregroundInsidePadding="false"
         android:foregroundGravity="fill_horizontal|top"
         android:foreground="?android:attr/windowContentOverlay" />
</LinearLayout>

Measure过程

MeaureSpec

MeaureSpec的含义

MeasureSpec 是一个32位int，高两位代表SpecMode,低30位代表SpecSize。

SpecMode 代表的测量模式

SpecSize 代表的是当前测量模式下的大小

private static boolean sUseBrokenMakeMeasureSpec = false;
   private static final int MODE_SHIFT = 30;
   //0x3=0b0011 ，这里相当于将32位的最高两位置1
   private static final int MODE_MASK  = 0x3 << MODE_SHIFT;	

        public static int makeMeasureSpec(int size, int mode) {
            if (sUseBrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode & MODE_MASK);
            }
        }
        
    public static int getMode(int measureSpec) {
            return (measureSpec & MODE_MASK);
    }

    public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
    }

SpecMode 的类型

UNSPECIFIED 子view要多大给多大，用于系统内部
EXACTLY 父容器已经知道子view多大，对应match_parent和具体值
AT_MOST 父容器告诉子view的允许的最大值。对应wrap_content

MeasureSpec 和 LayoutParams 的对应关系

MeasureSpec 是由LayoutParams和父容器才能决定。

DecorView 的MeasureSpec是由窗口尺寸和自身LayoutParams来共同确定。

viewGroup 测量子view的代码

protected void measureChildWithMargins(View child,
            int parentWidthMeasureSpec, int widthUsed,
            int parentHeightMeasureSpec, int heightUsed) {
        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                        + widthUsed, lp.width);
        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
                mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                        + heightUsed, lp.height);

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

这里可以发现核心方法是getChildMeasureSpec。所以

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        int specMode = MeasureSpec.getMode(spec);
        int specSize = MeasureSpec.getSize(spec);

		//这里的size为子元素最大可用大小，为父容器大小减去已占用的空间
        int size = Math.max(0, specSize - padding);

        int resultSize = 0;
        int resultMode = 0;

        switch (specMode) {
        // Parent has imposed an exact size on us
        case MeasureSpec.EXACTLY:
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size. So be it.
                resultSize = size;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                // Child wants to determine its own size. It can't be
                // bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;

        // Parent has imposed a maximum size on us
        case MeasureSpec.AT_MOST:
            if (childDimension >= 0) {
                // Child wants a specific size... so be it
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size, but our size is not fixed.
                // Constrain child to not be bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                // Child wants to determine its own size. It can't be
                // bigger than us.
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;

        // Parent asked to see how big we want to be
        case MeasureSpec.UNSPECIFIED:
            if (childDimension >= 0) {
                // Child wants a specific size... let him have it
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // Child wants to be our size... find out how big it should
                // be
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                // Child wants to determine its own size.... find out how
                // big it should be
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            }
            break;
        }
        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
    }

上面的代码虽然很长，但是很简单。表达的内容如下图

childLayoutParams和parentSpecMode	EXACTLY	AT_MOST	UNSPECIFED
dp/px	EXACTLY/childSize	EXACTLY/childSize	EXACTLY/childSize
match_parent	EXACTLY/parentSize	AT_MOST/parentSize	UNSPECIFED/0
wrap_content	AT_MOST/parentSize	AT_MOST/parentSize	UNSPECIFED/0

LinearLayout Measure 示例

首先看onMeasure

@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mOrientation == VERTICAL) {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        }
    }

这里可以看到，根据LinearLayout布局方向的不同，分了两个方法。但其实两个方法是差不多的。我们这里以measureVertical为例. 截取其中最核心的方法

for (int i = 0; i < count; ++i) {
            final View child = getVirtualChildAt(i);
            ...
            //这里调用child的measure。这里第四个参数是已经使用的宽度，由于这里是纵向线性布局，所以宽度是childen独占，
            //所以已使用的width 为0，最后一个为height，这里暂不讨论比重，当比重为0时，传入的已使用高度，即为mTotalLength
             measureChildBeforeLayout(
                       child, i, widthMeasureSpec, 0, heightMeasureSpec,
                       totalWeight == 0 ? mTotalLength : 0);

                if (oldHeight != Integer.MIN_VALUE) {
                   lp.height = oldHeight;
                }

                final int childHeight = child.getMeasuredHeight();
                final int totalLength = mTotalLength;
                //更新已占用的长度，包含子元素本身的长度和margin.
                mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                       lp.bottomMargin + getNextLocationOffset(child));

LinearLayout在更新完所有子元素的宽高后，LinearLayout会测量自己的宽高

mTotalLength += mPaddingTop + mPaddingBottom;

        int heightSize = mTotalLength;

        // Check against our minimum height
        heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
        
        // Reconcile our calculated size with the heightMeasureSpec
        //这里如果测量模式为EXACTLY ，或者AT_MOST模式specSize 小于heightSize，那么最后layout的高度为specSize
        //其他情况下，高度都是为heightSize
        int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
        heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
 	    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                heightSizeAndState);

获取view宽高的时机

由于view和activity的生命周期，并不是同步方法。我们无法在activity的某个生命周期中，确定view一定绘制完成。如果view还没有测量完毕，那么我们获取的宽高均为0

根据书上所示，我们在以下时机可以获取view的宽高

onWindowFocusChanged

含义是：view已经初始化完毕。当Activity得到和失去焦点均会被调用
view.post(runnable)

通过post将runnable投递到消息队列的尾部，等Looper调用此runnable的时候,view已经初始化好了
ViewTreeObserver

使用ViewTreeObserver里面的诸多回调都可以完成此功能。伴随着View树的改变，回调会多次调用
view.measure

手动对measure 进行测绘。如果view为固定的宽高或者wrap_content 则可以采用此方法。

由于手动measure 方法相当复杂，所以贴出相关代码

view 为固定宽高时，假设为100,则：

int widthMeasureSpec= View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY);
        int heightMeasureSpec= View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY);
        view.measure(widthMeasureSpec,heightMeasureSpec);

wrap_content:

int widthMeasureSpec= View.MeasureSpec.makeMeasureSpec((1<<30)-1, View.MeasureSpec.AT_MOST);
                int heightMeasureSpec= View.MeasureSpec.makeMeasureSpec((1<<30)-1, View.MeasureSpec.AT_MOST);
                view.measure(widthMeasureSpec,heightMeasureSpec);

这里我们假设view的父控件的宽高都是view 的宽高最大值，这样获取wrap_content是合理的。

注意 :如果在view以后测绘完成以后，手动调用measure方法，并且参数传入错误的话，可能会导致view按照错误的参数去重新绘制。

layout过程

layout 的过程和measure类似，都是先调用view的layout 方法。在layout方法中又会调用onlayout方法。

public void layout(int l, int t, int r, int b) {
        if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
            onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        }

        int oldL = mLeft;
        int oldT = mTop;
        int oldB = mBottom;
        int oldR = mRight;
		//这里将新的位置设置给view，并刷新view
        boolean changed = isLayoutModeOptical(mParent) ?
                setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

        if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
        	//这里调用了onLayout.
            onLayout(changed, l, t, r, b);
            mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;

            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnLayoutChangeListeners != null) {
                ArrayList<OnLayoutChangeListener> listenersCopy =
                        (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
                int numListeners = listenersCopy.size();
                for (int i = 0; i < numListeners; ++i) {
                    listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
                }
            }
        }

        mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
        mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
    }

而onLayout在view和viewgroup中均没有具体的实现，所以我们还是看LinearLayout

@Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if (mOrientation == VERTICAL) {
            layoutVertical(l, t, r, b);
        } else {
            layoutHorizontal(l, t, r, b);
        }
    }

这里我们和measure一样，还是选择layoutVertical方法来分析。

void layoutVertical(int left, int top, int right, int bottom) {
  		//...       
        final int count = getVirtualChildCount();
		//...
        for (int i = 0; i < count; i++) {
            final View child = getVirtualChildAt(i);
            if (child == null) {
                childTop += measureNullChild(i);
            } else if (child.getVisibility() != GONE) {
                final int childWidth = child.getMeasuredWidth();
                final int childHeight = child.getMeasuredHeight();
                
                final LinearLayout.LayoutParams lp =
                        (LinearLayout.LayoutParams) child.getLayoutParams();
                	//....
                if (hasDividerBeforeChildAt(i)) {
                    childTop += mDividerHeight;
                }
                childTop += lp.topMargin;
                //这里就调用子元素的layout方法。而这里传递给子元素的宽度和高度就是childWidth和childHeight
                setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                        childWidth, childHeight);
                //这里childTop是不断增大的，每次都加上这次的childHeight
                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);

                i += getChildrenSkipCount(child, i);
            }
        }
    }

这里可以看到传递给子元素的宽度和高度就是childWidth和childHeight.而在上面的代码中

final int childWidth = child.getMeasuredWidth();
                final int childHeight = child.getMeasuredHeight();

所以，这里可以看到最终传递到给子元素的宽度和高度，就是MeasureWidth和MeasureHeight。

所以，我们可以认为在一般的view中，最终的宽高就是MeasureWidth和MeasureHeight。除非我们在layout中故意重写，最终传入的宽高。

draw过程

这里我们先看view的draw的源码

public void draw(Canvas canvas) {
        final int privateFlags = mPrivateFlags;
        final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
                (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
        mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;

        /*
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *      1. Draw the background
         *      2. If necessary, save the canvas' layers to prepare for fading
         *      3. Draw view's content
         *      4. Draw children
         *      5. If necessary, draw the fading edges and restore layers
         *      6. Draw decorations (scrollbars for instance)
         */
		/*
	 	* 上面的话翻译过来就是
	 	* 绘制背景
	 	* 绘制自己
	 	* 绘制children
	 	* 绘制装饰
	 	*/
        // Step 1, draw the background, if needed
        int saveCount;

        if (!dirtyOpaque) {
        	//第一步绘制背景
            drawBackground(canvas);
        }

        // skip step 2 & 5 if possible (common case)
        final int viewFlags = mViewFlags;
        boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
        boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
        if (!verticalEdges && !horizontalEdges) {
            // Step 3, draw the content
            //绘制自己
            if (!dirtyOpaque) onDraw(canvas);

            // Step 4, draw the children
            //绘制children
            dispatchDraw(canvas);

            // Overlay is part of the content and draws beneath Foreground
            if (mOverlay != null && !mOverlay.isEmpty()) {
                mOverlay.getOverlayView().dispatchDraw(canvas);
            }

            // Step 6, draw decorations (foreground, scrollbars)
            //绘制装饰
            onDrawForeground(canvas);

            // we're done...
            return;
        }

        /*
         * Here we do the full fledged routine...
         * (this is an uncommon case where speed matters less,
         * this is why we repeat some of the tests that have been
         * done above)
         */

        boolean drawTop = false;
        boolean drawBottom = false;
        boolean drawLeft = false;
        boolean drawRight = false;

        float topFadeStrength = 0.0f;
        float bottomFadeStrength = 0.0f;
        float leftFadeStrength = 0.0f;
        float rightFadeStrength = 0.0f;

        // Step 2, save the canvas' layers
        int paddingLeft = mPaddingLeft;

        final boolean offsetRequired = isPaddingOffsetRequired();
        if (offsetRequired) {
            paddingLeft += getLeftPaddingOffset();
        }

        int left = mScrollX + paddingLeft;
        int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
        int top = mScrollY + getFadeTop(offsetRequired);
        int bottom = top + getFadeHeight(offsetRequired);

        if (offsetRequired) {
            right += getRightPaddingOffset();
            bottom += getBottomPaddingOffset();
        }

        final ScrollabilityCache scrollabilityCache = mScrollCache;
        final float fadeHeight = scrollabilityCache.fadingEdgeLength;
        int length = (int) fadeHeight;

        // clip the fade length if top and bottom fades overlap
        // overlapping fades produce odd-looking artifacts
        if (verticalEdges && (top + length > bottom - length)) {
            length = (bottom - top) / 2;
        }

        // also clip horizontal fades if necessary
        if (horizontalEdges && (left + length > right - length)) {
            length = (right - left) / 2;
        }

        if (verticalEdges) {
            topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));
            drawTop = topFadeStrength * fadeHeight > 1.0f;
            bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));
            drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
        }

        if (horizontalEdges) {
            leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));
            drawLeft = leftFadeStrength * fadeHeight > 1.0f;
            rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));
            drawRight = rightFadeStrength * fadeHeight > 1.0f;
        }

        saveCount = canvas.getSaveCount();

        int solidColor = getSolidColor();
        if (solidColor == 0) {
            final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;

            if (drawTop) {
                canvas.saveLayer(left, top, right, top + length, null, flags);
            }

            if (drawBottom) {
                canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
            }

            if (drawLeft) {
                canvas.saveLayer(left, top, left + length, bottom, null, flags);
            }

            if (drawRight) {
                canvas.saveLayer(right - length, top, right, bottom, null, flags);
            }
        } else {
            scrollabilityCache.setFadeColor(solidColor);
        }

        // Step 3, draw the content
        if (!dirtyOpaque) onDraw(canvas);

        // Step 4, draw the children
        dispatchDraw(canvas);

        // Step 5, draw the fade effect and restore layers
        final Paint p = scrollabilityCache.paint;
        final Matrix matrix = scrollabilityCache.matrix;
        final Shader fade = scrollabilityCache.shader;

        if (drawTop) {
            matrix.setScale(1, fadeHeight * topFadeStrength);
            matrix.postTranslate(left, top);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(left, top, right, top + length, p);
        }

        if (drawBottom) {
            matrix.setScale(1, fadeHeight * bottomFadeStrength);
            matrix.postRotate(180);
            matrix.postTranslate(left, bottom);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(left, bottom - length, right, bottom, p);
        }

        if (drawLeft) {
            matrix.setScale(1, fadeHeight * leftFadeStrength);
            matrix.postRotate(-90);
            matrix.postTranslate(left, top);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(left, top, left + length, bottom, p);
        }

        if (drawRight) {
            matrix.setScale(1, fadeHeight * rightFadeStrength);
            matrix.postRotate(90);
            matrix.postTranslate(right, top);
            fade.setLocalMatrix(matrix);
            p.setShader(fade);
            canvas.drawRect(right - length, top, right, bottom, p);
        }

        canvas.restoreToCount(saveCount);

        // Overlay is part of the content and draws beneath Foreground
        if (mOverlay != null && !mOverlay.isEmpty()) {
            mOverlay.getOverlayView().dispatchDraw(canvas);
        }

        // Step 6, draw decorations (foreground, scrollbars)
        onDrawForeground(canvas);
    }

在view 的方法中，有个方法需要特别注意一下，就是setWillNotDraw。如果setWillNotDraw开启以后，系统将默认优化，对自身不再绘制。在viewgroup中，是默认打开了此配置。如果我们自定义的viewgroup需要绘制自身，则需要打开此配置。

自定义view注意事项

直接继承view ，需要实现warp_content支持
需要实现padding的支持
直接使用view内部handler
线程和动画，注意生命周期onAttachedToWindow和onDetachedFromWindow
嵌套滑动冲突

读书笔记——《Android 开发艺术探索》View的工作原理阅读笔记初识ViewRoot和DecorViewMeasure过程layout过程draw过程自定义view注意事项

View的工作原理阅读笔记

初识ViewRoot和DecorView

DecorView的结构

Measure过程

MeaureSpec

MeaureSpec的含义

SpecMode 的类型

MeasureSpec 和 LayoutParams 的对应关系

LinearLayout Measure 示例

获取view宽高的时机

layout过程

draw过程

自定义view注意事项

继续阅读

专访邓凡平：深入理解Android

与专家面对面：Android开发入门问与答

Android MVP架构MVCMVP

mvp初探

Android常用工具类简介目录

android常用工具类转载自：http://www.trinea.cn/android/android-common-utils/Android常用工具类

Android常用工具类ToastUtilsSizeUtilsLogUtilsRetrofitManagerAnimUtil

Android Studio 0.8.0解决 Failure [INSTALL_FAILED_OLDER_SDK] 问题

Android – ListView 中添加按钮，动态删除添加ItemView的操作

Kotlin的ListView与RecyclerView的简单应用

关于公司的那些坑：Android Studio篇

android SQLite事务和kotlin协程

无法正常编译错误Compilation failed to complete

关于Gradle配置的小结

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Android APK文件反编译Android APK文件反编译