Android: framelayout Research

Framelayout is mysterious because it is used in a small number of places, and has always felt that it is ignorant. Recently, we need to implement some layer effects and use it. Its usage is very simple. I will not talk about it here. Let's talk about its principles here.

There is nothing in the framelayout class. It mainly refers to its own layout parameter framelayout. layoutparams. The layout parameter class inherits marginlayoutparams. The concept is to control the margin of the view. framelayout. layoutparams has only one gravity defined by itself.

Now that layout parameters are available, there will be some space attributes. First, framelayout is also a view, so it must have attributes related to the padding (view padding. Here we focus on onmeasure and onlayout:

Onmeasure is used to calculate the layout size of the viewgroup and the layout size of the Child view.

Onmeasure

 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int count = getChildCount();

final boolean measureMatchParentChildren =
                MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
                MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
        mMatchParentChildren.clear();

int maxHeight = 0;
int maxWidth = 0;
int childState = 0;

for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (mMeasureAllChildren || child.getVisibility() != GONE) {
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
                maxWidth = Math.max(maxWidth,
                        child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
                maxHeight = Math.max(maxHeight,
                        child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
                childState = combineMeasuredStates(childState, child.getMeasuredState());
if (measureMatchParentChildren) {
if (lp.width == LayoutParams.MATCH_PARENT ||
                            lp.height == LayoutParams.MATCH_PARENT) {
                        mMatchParentChildren.add(child);
                    }
                }
            }
        }

// Account for padding too
        maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
        maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

// Check against our minimum height and width
        maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
        maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

// Check against our foreground's minimum height and width
        final Drawable drawable = getForeground();
if (drawable != null) {
            maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
            maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
        }

        setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                resolveSizeAndState(maxHeight, heightMeasureSpec,
                        childState << MEASURED_HEIGHT_STATE_SHIFT));

        count = mMatchParentChildren.size();
if (count > 1) {
for (int i = 0; i < count; i++) {
final View child = mMatchParentChildren.get(i);

final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
int childWidthMeasureSpec;
int childHeightMeasureSpec;

if (lp.width == LayoutParams.MATCH_PARENT) {
                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -
                            getPaddingLeftWithForeground() - getPaddingRightWithForeground() -
                            lp.leftMargin - lp.rightMargin,
                            MeasureSpec.EXACTLY);
                } else {
                    childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                            getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                            lp.leftMargin + lp.rightMargin,
                            lp.width);
                }

if (lp.height == LayoutParams.MATCH_PARENT) {
                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -
                            getPaddingTopWithForeground() - getPaddingBottomWithForeground() -
                            lp.topMargin - lp.bottomMargin,
                            MeasureSpec.EXACTLY);
                } else {
                    childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                            getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                            lp.topMargin + lp.bottomMargin,
                            lp.height);
                }

                child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
            }
        }
    }

In short, the width of the parent container is the width of all child views. The maximum value is used to add the view outer margin and its inner margin: child. getmeasuredwidth () + LP. leftmargin + LP. rightmargin + getpaddingleftwithforeground () + getpaddingrightwithforeground (); If the viewgroup has images and the image is larger than the image, the height of the container is the same. The layout of the framelayout child view is the same as that of the normal view.

　　

Onlayout

 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
final int count = getChildCount();

final int parentLeft = getPaddingLeftWithForeground();
final int parentRight = right - left - getPaddingRightWithForeground();

final int parentTop = getPaddingTopWithForeground();
final int parentBottom = bottom - top - getPaddingBottomWithForeground();

        mForegroundBoundsChanged = true;

for (int i = 0; i < count; i++) {
final View child = getChildAt(i);
if (child.getVisibility() != GONE) {
final LayoutParams lp = (LayoutParams) child.getLayoutParams();

final int width = child.getMeasuredWidth();
final int height = child.getMeasuredHeight();

int childLeft;
int childTop;

int gravity = lp.gravity;
if (gravity == -1) {
                    gravity = DEFAULT_CHILD_GRAVITY;
                }

final int layoutDirection = getResolvedLayoutDirection();
final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;

switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
case Gravity.LEFT:
                        childLeft = parentLeft + lp.leftMargin;
break;
case Gravity.CENTER_HORIZONTAL:
                        childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
                        lp.leftMargin - lp.rightMargin;
break;
case Gravity.RIGHT:
                        childLeft = parentRight - width - lp.rightMargin;
break;
default:
                        childLeft = parentLeft + lp.leftMargin;
                }

switch (verticalGravity) {
case Gravity.TOP:
                        childTop = parentTop + lp.topMargin;
break;
case Gravity.CENTER_VERTICAL:
                        childTop = parentTop + (parentBottom - parentTop - height) / 2 +
                        lp.topMargin - lp.bottomMargin;
break;
case Gravity.BOTTOM:
                        childTop = parentBottom - height - lp.bottomMargin;
break;
default:
                        childTop = parentTop + lp.topMargin;
                }

                child.layout(childLeft, childTop, childLeft + width, childTop + height);
            }
        }
    }

From the code, we can see that the X value of the coordinate in the upper left corner of the Child view is the left margin of the viewgroup plus the view margin, and the Y value is the same.

Ah, how do you feel that you have written and written, and you have made the problem more complicated? You still feel that you can understand the code.

In addition, in code 2.2, gravity and margin attributes must be set at the same time before margin can play a role. If only the margin attribute is set but not gravity, the effect will be ineffective. If anyone knows, please kindly advise.

In the previous article, I talked about drag and drop a view in Android. At that time, the imageview was placed in a linearlayout. In fact, it also applies to framelayout because their layout parameters inherit the marginlayoutparams class, therefore, using margin to control their layout is also used in framelayout. In fact, the layout parameters of gridlayout, linearlayout, relativelayout, and framelayout are inherited from marginlayoutparams.