Android RelativeLayout(7.1) 源码解析

最新推荐文章于 2024-06-04 21:31:16 发布
最新推荐文章于 2024-06-04 21:31:16 发布
阅读量568 收藏 1
点赞数 1
分类专栏： android 文章标签： android relativelayout 布局
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenshuwan/article/details/70228671
版权

这节看一下RelativeLayout是如何实现的，它继承ViewGroup，下面主要分析它的
1、onMeasure
2、onLayout
Note：
1、onMeasure时，有三种测量模式：UNSPECIFIED、EXACTLY、AT_MOST
2、UNSPECIFIED 发生在创建的View没有明确layout_width和layout_height
3、EXACTLY发生在明确layout_width和layout_height具体大小，或者设置value为match_parent
4、AT_MOST发生在 layout_width和layout_height的value为wrap_content
5、下面定义 水平方向例外规则为:(LEFT_OF, RIGHT_OF, ALIGN_LEFT, ALIGN_RIGHT, START_OF, END_OF, ALIGN_START, ALIGN_END)
6、下面定义垂直方向的依赖关系为：(ABOVE,BELOW, ALIGN_BASELINE, ALIGN_TOP, ALIGN_BOTTOM)

下面是onMeasure的全部code

RelativeLayout.java
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mDirtyHierarchy) {
            mDirtyHierarchy = false;
            sortChildren();
        }

        int myWidth = -1;
        int myHeight = -1;

        int width = 0;
        int height = 0;

        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        final int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        // Record our dimensions if they are known;
        if (widthMode != MeasureSpec.UNSPECIFIED) {
            myWidth = widthSize;
        }

        if (heightMode != MeasureSpec.UNSPECIFIED) {
            myHeight = heightSize;
        }

        if (widthMode == MeasureSpec.EXACTLY) {
            width = myWidth;
        }

        if (heightMode == MeasureSpec.EXACTLY) {
            height = myHeight;
        }

        View ignore = null;
        int gravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
        final boolean horizontalGravity = gravity != Gravity.START && gravity != 0;
        gravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
        final boolean verticalGravity = gravity != Gravity.TOP && gravity != 0;

        int left = Integer.MAX_VALUE;
        int top = Integer.MAX_VALUE;
        int right = Integer.MIN_VALUE;
        int bottom = Integer.MIN_VALUE;

        boolean offsetHorizontalAxis = false;
        boolean offsetVerticalAxis = false;

        if ((horizontalGravity || verticalGravity) && mIgnoreGravity != View.NO_ID) {
            ignore = findViewById(mIgnoreGravity);
        }

        final boolean isWrapContentWidth = widthMode != MeasureSpec.EXACTLY;
        final boolean isWrapContentHeight = heightMode != MeasureSpec.EXACTLY;

        // We need to know our size for doing the correct computation of children positioning in RTL
        // mode but there is no practical way to get it instead of running the code below.
        // So, instead of running the code twice, we just set the width to a "default display width"
        // before the computation and then, as a last pass, we will update their real position with
        // an offset equals to "DEFAULT_WIDTH - width".
        final int layoutDirection = getLayoutDirection();
        if (isLayoutRtl() && myWidth == -1) {
            myWidth = DEFAULT_WIDTH;
        }

        View[] views = mSortedHorizontalChildren;
        int count = views.length;

        for (int i = 0; i < count; i++) {
            View child = views[i];
            if (child.getVisibility() != GONE) {
                LayoutParams params = (LayoutParams) child.getLayoutParams();
                int[] rules = params.getRules(layoutDirection);

                applyHorizontalSizeRules(params, myWidth, rules);
                measureChildHorizontal(child, params, myWidth, myHeight);

                if (positionChildHorizontal(child, params, myWidth, isWrapContentWidth)) {
                    offsetHorizontalAxis = true;
                }
            }
        }

        views = mSortedVerticalChildren;
        count = views.length;
        final int targetSdkVersion = getContext().getApplicationInfo().targetSdkVersion;

        for (int i = 0; i < count; i++) {
            final View child = views[i];
            if (child.getVisibility() != GONE) {
                final LayoutParams params = (LayoutParams) child.getLayoutParams();

                applyVerticalSizeRules(params, myHeight, child.getBaseline());
                measureChild(child, params, myWidth, myHeight);
                if (positionChildVertical(child, params, myHeight, isWrapContentHeight)) {
                    offsetVerticalAxis = true;
                }

                if (isWrapContentWidth) {
                    if (isLayoutRtl()) {
                        if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                            width = Math.max(width, myWidth - params.mLeft);
                        } else {
                            width = Math.max(width, myWidth - params.mLeft - params.leftMargin);
                        }
                    } else {
                        if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                            width = Math.max(width, params.mRight);
                        } else {
                            width = Math.max(width, params.mRight + params.rightMargin);
                        }
                    }
                }

                if (isWrapContentHeight) {
                    if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                        height = Math.max(height, params.mBottom);
                    } else {
                        height = Math.max(height, params.mBottom + params.bottomMargin);
                    }
                }

                if (child != ignore || verticalGravity) {
                    left = Math.min(left, params.mLeft - params.leftMargin);
                    top = Math.min(top, params.mTop - params.topMargin);
                }

                if (child != ignore || horizontalGravity) {
                    right = Math.max(right, params.mRight + params.rightMargin);
                    bottom = Math.max(bottom, params.mBottom + params.bottomMargin);
                }
            }
        }

        // Use the top-start-most laid out view as the baseline. RTL offsets are
        // applied later, so we can use the left-most edge as the starting edge.
        View baselineView = null;
        LayoutParams baselineParams = null;
        for (int i = 0; i < count; i++) {
            final View child = views[i];
            if (child.getVisibility() != GONE) {
                final LayoutParams childParams = (LayoutParams) child.getLayoutParams();
                if (baselineView == null || baselineParams == null
                        || compareLayoutPosition(childParams, baselineParams) < 0) {
                    baselineView = child;
                    baselineParams = childParams;
                }
            }
        }
        mBaselineView = baselineView;

        if (isWrapContentWidth) {
            // Width already has left padding in it since it was calculated by looking at
            // the right of each child view
            width += mPaddingRight;

            if (mLayoutParams != null && mLayoutParams.width >= 0) {
                width = Math.max(width, mLayoutParams.width);
            }

            width = Math.max(width, getSuggestedMinimumWidth());
            width = resolveSize(width, widthMeasureSpec);

            if (offsetHorizontalAxis) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        final int[] rules = params.getRules(layoutDirection);
                        if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_HORIZONTAL] != 0) {
                            centerHorizontal(child, params, width);
                        } else if (rules[ALIGN_PARENT_RIGHT] != 0) {
                            final int childWidth = child.getMeasuredWidth();
                            params.mLeft = width - mPaddingRight - childWidth;
                            params.mRight = params.mLeft + childWidth;
                        }
                    }
                }
            }
        }

        if (isWrapContentHeight) {
            // Height already has top padding in it since it was calculated by looking at
            // the bottom of each child view
            height += mPaddingBottom;

            if (mLayoutParams != null && mLayoutParams.height >= 0) {
                height = Math.max(height, mLayoutParams.height);
            }

            height = Math.max(height, getSuggestedMinimumHeight());
            height = resolveSize(height, heightMeasureSpec);

            if (offsetVerticalAxis) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        final int[] rules = params.getRules(layoutDirection);
                        if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_VERTICAL] != 0) {
                            centerVertical(child, params, height);
                        } else if (rules[ALIGN_PARENT_BOTTOM] != 0) {
                            final int childHeight = child.getMeasuredHeight();
                            params.mTop = height - mPaddingBottom - childHeight;
                            params.mBottom = params.mTop + childHeight;
                        }
                    }
                }
            }
        }

        if (horizontalGravity || verticalGravity) {
            final Rect selfBounds = mSelfBounds;
            selfBounds.set(mPaddingLeft, mPaddingTop, width - mPaddingRight,
                    height - mPaddingBottom);

            final Rect contentBounds = mContentBounds;
            Gravity.apply(mGravity, right - left, bottom - top, selfBounds, contentBounds,
                    layoutDirection);

            final int horizontalOffset = contentBounds.left - left;
            final int verticalOffset = contentBounds.top - top;
            if (horizontalOffset != 0 || verticalOffset != 0) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE && child != ignore) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        if (horizontalGravity) {
                            params.mLeft += horizontalOffset;
                            params.mRight += horizontalOffset;
                        }
                        if (verticalGravity) {
                            params.mTop += verticalOffset;
                            params.mBottom += verticalOffset;
                        }
                    }
                }
            }
        }

        if (isLayoutRtl()) {
            final int offsetWidth = myWidth - width;
            for (int i = 0; i < count; i++) {
                final View child = views[i];
                if (child.getVisibility() != GONE) {
                    final LayoutParams params = (LayoutParams) child.getLayoutParams();
                    params.mLeft -= offsetWidth;
                    params.mRight -= offsetWidth;
                }
            }
        }

        setMeasuredDimension(width, height);
    }

接下来，我们一点一点的分析上面的code

onMeasure
  if (mDirtyHierarchy) {
            mDirtyHierarchy = false;
            sortChildren();
        }

        int myWidth = -1;
        int myHeight = -1;

        int width = 0;
        int height = 0;

        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        final int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        // Record our dimensions if they are known;
        if (widthMode != MeasureSpec.UNSPECIFIED) {
            myWidth = widthSize;
        }

        if (heightMode != MeasureSpec.UNSPECIFIED) {
            myHeight = heightSize;
        }

        if (widthMode == MeasureSpec.EXACTLY) {
            width = myWidth;
        }

        if (heightMode == MeasureSpec.EXACTLY) {
            height = myHeight;
        }

1、当view执行requestLayout时，mDirtyHierarchy会变为true，此时就会执行sortChildren()方法，该方法 主要是将RelativeLayout的sub child进行两种规则的排序，一种是按照水平依赖关系(LEFT_OF、RIGHT_OF,etc)进行排序用数组mSortedHorizontalChildren保存结果，另一种是按照垂直依赖关系(ABOVE、BELOW,etc)进行排序用数组mSortedVerticalChildren保存结果
2、MeasureSpec.getMode获得开始时的measure mode
3、MeasureSpec.getSize或则开始时的width 和height

final int layoutDirection = getLayoutDirection();

这里我们默认的layoutDirection是LTR：水平方向从左往右排版，
而RTL正好相反，是从右向左排版,如下图
这里写图片描述

onMeasure
 View[] views = mSortedHorizontalChildren;
        int count = views.length;

        for (int i = 0; i < count; i++) {
            View child = views[i];
            if (child.getVisibility() != GONE) {
                LayoutParams params = (LayoutParams) child.getLayoutParams();
                int[] rules = params.getRules(layoutDirection);

                applyHorizontalSizeRules(params, myWidth, rules);
                measureChildHorizontal(child, params, myWidth, myHeight);

                if (positionChildHorizontal(child, params, myWidth, isWrapContentWidth)) {
                    offsetHorizontalAxis = true;
                }
            }
        }

1、applyHorizontalSizeRules方法通过水平方向的依赖规则对params的right和left进行计算赋值
2、measureChildHorizontal 方法里面主要是调用child.mesuare方法
3、positionChildHorizontal 这个方法判断改child view是否设置在 parent view里面为水平居中

onMeasure
 views = mSortedVerticalChildren;
        count = views.length;
        final int targetSdkVersion = getContext().getApplicationInfo().targetSdkVersion;

        for (int i = 0; i < count; i++) {
            final View child = views[i];
            if (child.getVisibility() != GONE) {
                final LayoutParams params = (LayoutParams) child.getLayoutParams();

                applyVerticalSizeRules(params, myHeight, child.getBaseline());
                measureChild(child, params, myWidth, myHeight);
                if (positionChildVertical(child, params, myHeight, isWrapContentHeight)) {
                    offsetVerticalAxis = true;
                }

                if (isWrapContentWidth) {
                    if (isLayoutRtl()) {
                        if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                            width = Math.max(width, myWidth - params.mLeft);
                        } else {
                            width = Math.max(width, myWidth - params.mLeft - params.leftMargin);
                        }
                    } else {
                        if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                            width = Math.max(width, params.mRight);
                        } else {
                            width = Math.max(width, params.mRight + params.rightMargin);
                        }
                    }
                }

                if (isWrapContentHeight) {
                    if (targetSdkVersion < Build.VERSION_CODES.KITKAT) {
                        height = Math.max(height, params.mBottom);
                    } else {
                        height = Math.max(height, params.mBottom + params.bottomMargin);
                    }
                }

                if (child != ignore || verticalGravity) {
                    left = Math.min(left, params.mLeft - params.leftMargin);
                    top = Math.min(top, params.mTop - params.topMargin);
                }

                if (child != ignore || horizontalGravity) {
                    right = Math.max(right, params.mRight + params.rightMargin);
                    bottom = Math.max(bottom, params.mBottom + params.bottomMargin);
                }
            }
        }

这里的code logic不做多少讲解

onMeasure
  View baselineView = null;
        LayoutParams baselineParams = null;
        for (int i = 0; i < count; i++) {
            final View child = views[i];
            if (child.getVisibility() != GONE) {
                final LayoutParams childParams = (LayoutParams) child.getLayoutParams();
                if (baselineView == null || baselineParams == null
                        || compareLayoutPosition(childParams, baselineParams) < 0) {
                    baselineView = child;
                    baselineParams = childParams;
                }
            }
        }
        mBaselineView = baselineView;

这几行code是为了找出在最left和最top的 View,用mBaselineView保存符合条件的view

onMeasure
 if (isWrapContentWidth) {
            // Width already has left padding in it since it was calculated by looking at
            // the right of each child view
            width += mPaddingRight;

            if (mLayoutParams != null && mLayoutParams.width >= 0) {
                width = Math.max(width, mLayoutParams.width);
            }

            width = Math.max(width, getSuggestedMinimumWidth());
            width = resolveSize(width, widthMeasureSpec);

            if (offsetHorizontalAxis) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        final int[] rules = params.getRules(layoutDirection);
                        if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_HORIZONTAL] != 0) {
                            centerHorizontal(child, params, width);
                        } else if (rules[ALIGN_PARENT_RIGHT] != 0) {
                            final int childWidth = child.getMeasuredWidth();
                            params.mLeft = width - mPaddingRight - childWidth;
                            params.mRight = params.mLeft + childWidth;
                        }
                    }
                }
            }
        }

这里code很简单，centerHorizontal 这个方法是设置params的left和right的值

onMeasure
if (isWrapContentHeight) {
            // Height already has top padding in it since it was calculated by looking at
            // the bottom of each child view
            height += mPaddingBottom;

            if (mLayoutParams != null && mLayoutParams.height >= 0) {
                height = Math.max(height, mLayoutParams.height);
            }

            height = Math.max(height, getSuggestedMinimumHeight());
            height = resolveSize(height, heightMeasureSpec);

            if (offsetVerticalAxis) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        final int[] rules = params.getRules(layoutDirection);
                        if (rules[CENTER_IN_PARENT] != 0 || rules[CENTER_VERTICAL] != 0) {
                            centerVertical(child, params, height);
                        } else if (rules[ALIGN_PARENT_BOTTOM] != 0) {
                            final int childHeight = child.getMeasuredHeight();
                            params.mTop = height - mPaddingBottom - childHeight;
                            params.mBottom = params.mTop + childHeight;
                        }
                    }
                }
            }
        }

这里的code不做多少解析，继续往下看

onMeasure
 if (horizontalGravity || verticalGravity) {
            final Rect selfBounds = mSelfBounds;
            selfBounds.set(mPaddingLeft, mPaddingTop, width - mPaddingRight,
                    height - mPaddingBottom);

            final Rect contentBounds = mContentBounds;
            Gravity.apply(mGravity, right - left, bottom - top, selfBounds, contentBounds,
                    layoutDirection);

            final int horizontalOffset = contentBounds.left - left;
            final int verticalOffset = contentBounds.top - top;
            if (horizontalOffset != 0 || verticalOffset != 0) {
                for (int i = 0; i < count; i++) {
                    final View child = views[i];
                    if (child.getVisibility() != GONE && child != ignore) {
                        final LayoutParams params = (LayoutParams) child.getLayoutParams();
                        if (horizontalGravity) {
                            params.mLeft += horizontalOffset;
                            params.mRight += horizontalOffset;
                        }
                        if (verticalGravity) {
                            params.mTop += verticalOffset;
                            params.mBottom += verticalOffset;
                        }
                    }
                }
            }
        }

这里code主要功能还是对设置在parent view中水平居中或者垂直居中的处理

onMeasure
 setMeasuredDimension(width, height);

最后一行 设置RelativeLayout本身测量的width和height
以上是onMeasure的大概执行过程，下面我们看一下onMeasure里面调用的几个method

onMeasure -> sortChildren
private void sortChildren() {
        final int count = getChildCount();
        if (mSortedVerticalChildren == null || mSortedVerticalChildren.length != count) {
            mSortedVerticalChildren = new View[count];
        }

        if (mSortedHorizontalChildren == null || mSortedHorizontalChildren.length != count) {
            mSortedHorizontalChildren = new View[count];
        }

        final DependencyGraph graph = mGraph;
        graph.clear();

        for (int i = 0; i < count; i++) {
            graph.add(getChildAt(i));
        }

        graph.getSortedViews(mSortedVerticalChildren, RULES_VERTICAL);
        graph.getSortedViews(mSortedHorizontalChildren, RULES_HORIZONTAL);
    }

code很简单，我们看一下graph.getSortedViews方法

void getSortedViews(View[] sorted, int... rules) {
            final ArrayDeque<Node> roots = findRoots(rules);
            int index = 0;

            Node node;
            while ((node = roots.pollLast()) != null) {
                final View view = node.view;
                final int key = view.getId();

                sorted[index++] = view;

                final ArrayMap<Node, DependencyGraph> dependents = node.dependents;
                final int count = dependents.size();
                for (int i = 0; i < count; i++) {
                    final Node dependent = dependents.keyAt(i);
                    final SparseArray<Node> dependencies = dependent.dependencies;

                    dependencies.remove(key);
                    if (dependencies.size() == 0) {
                        roots.add(dependent);
                    }
                }
            }

            if (index < sorted.length) {
                throw new IllegalStateException("Circular dependencies cannot exist"
                        + " in RelativeLayout");
            }
        }

1、这里面一开始调用了findRoots方法，该方法是找出所有完全不依赖其它view的RelativeLayout的child view
2、这里用到一个类Note，其中Node.dependents保存的是布局上其它所有依赖此Node的view信息，Node.dependencies保存的是此Node布局上所依赖的所有的View信息

onMeasure -> applyHorizontalSizeRules

private void applyHorizontalSizeRules(LayoutParams childParams, int myWidth, int[] rules) {
        RelativeLayout.LayoutParams anchorParams;    
        childParams.mLeft = VALUE_NOT_SET;
        childParams.mRight = VALUE_NOT_SET;

        anchorParams = getRelatedViewParams(rules, LEFT_OF);
        if (anchorParams != null) {
            childParams.mRight = anchorParams.mLeft - (anchorParams.leftMargin +
                    childParams.rightMargin);
        } else if (childParams.alignWithParent && rules[LEFT_OF] != 0) {
            if (myWidth >= 0) {
                childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
            }
        }

        anchorParams = getRelatedViewParams(rules, RIGHT_OF);
        if (anchorParams != null) {
            childParams.mLeft = anchorParams.mRight + (anchorParams.rightMargin +
                    childParams.leftMargin);
        } else if (childParams.alignWithParent && rules[RIGHT_OF] != 0) {
            childParams.mLeft = mPaddingLeft + childParams.leftMargin;
        }

        anchorParams = getRelatedViewParams(rules, ALIGN_LEFT);
        if (anchorParams != null) {
            childParams.mLeft = anchorParams.mLeft + childParams.leftMargin;
        } else if (childParams.alignWithParent && rules[ALIGN_LEFT] != 0) {
            childParams.mLeft = mPaddingLeft + childParams.leftMargin;
        }

        anchorParams = getRelatedViewParams(rules, ALIGN_RIGHT);
        if (anchorParams != null) {
            childParams.mRight = anchorParams.mRight - childParams.rightMargin;
        } else if (childParams.alignWithParent && rules[ALIGN_RIGHT] != 0) {
            if (myWidth >= 0) {
                childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
            }
        }

        if (0 != rules[ALIGN_PARENT_LEFT]) {
            childParams.mLeft = mPaddingLeft + childParams.leftMargin;
        }

        if (0 != rules[ALIGN_PARENT_RIGHT]) {
            if (myWidth >= 0) {
                childParams.mRight = myWidth - mPaddingRight - childParams.rightMargin;
            }
        }
    }

该方法根据水平方向的依赖规则去计算view params的right和left的值

在onMeasure其它的一些方法例如measureChildHorizontal、positionChildHorizontal等这样的Method都是一些logic的处理，感兴趣的可以自己查看一下source code

下面我们看一下onLayout的具体实现：

 protected void onLayout(boolean changed, int l, int t, int r, int b) {
        //  The layout has actually already been performed and the positions
        //  cached.  Apply the cached values to the children.
        final int count = getChildCount();

        for (int i = 0; i < count; i++) {
            View child = getChildAt(i);
            if (child.getVisibility() != GONE) {
                RelativeLayout.LayoutParams st =
                        (RelativeLayout.LayoutParams) child.getLayoutParams();
                child.layout(st.mLeft, st.mTop, st.mRight, st.mBottom);
            }
        }
    }

从code上来看，onLayout的实现很简单，原因是onMeasure里面已经处理好了每一个view的left 、top、right、bottom的值，所以这里只需要简单遍历所有的view并执行child.layout就ok了

summary：
RelativeLayout利用位置上相对依赖的关系，计算出每一个view的上下左右的值，我们可以从读code中来学习 编写自定义控件的ideal

chenshuwan
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android View系列(二)——RelativeLayout源码分析
hesheng1024的博客
04-13 180
title: Android View系列(二)——RelativeLayout源码分析 tag: Android源码 category: Android date: 2019-05-01 文章目录RelativeLayout源码简介onMeasure排序排序后初始化水平方向垂直方向Baseline的计算一些修正onLayoutonDraw总结FrameLayout、LinearLayout...
android适配右到左布局注意事项
to_perfect的博客
12-09 7731
  呜呼，伊朗的项目终于做完了，大部分都是在整理右到左布局的需求。好在android sdk 从API17（Android4.2）开始支持右到左布局的需求，但是会有很多坑需要去填。   Android中的大部分组件是支持右到左布局的，只需要在Androidmanifest中配置如下： &amp;lt;application .... android:supportsRt...
关于对安卓开发的总结
最新发布
l12345833的博客
06-04 966
理解Android Studio中各种布局的重要性在于它们是构建Android应用界面的基础。通过正确选择和灵活运用不同类型的布局，开发者可以更高效地创建出美观、响应式的用户界面。在Android Studio中，常见的布局类型包括线性布局、约束布局、表格布局、帧布局和相对布局。下面我将详细介绍每种布局的特点、适用场景以及如何在实际项目中应用这些布局。
Android 代码动态修改RelativeLayout布局
使命初始的博客
01-29 1416
Android 代码动态修改RelativeLayout布局 前言 有时我们会遇到在xml布局文件中设置好界面后,但是又需要从代码中进行动态布局修改。 之前从网上寻找了好多资料，看到的都是新建一个布局文件 但是我的需求又是从当前布局文件的基础上进行修改。 下面用一个示例大家介绍一个比较简单的办法。 演示 该例子主要是使用RelativeLayout布局,放置两个TextView,点击切换按钮进行切换，永远有一个TextView保持屏幕中间。 activity_main.xml <?xml versi
RelativeLayout相对布局详解
chuyouyinghe的专栏
09-20 2690
RelativeLayout相对布局在Android UI开发中也应用比较多，虽然它不及LinearLayout使用方便，但某些场景中使用RelativeLayout也是一种很不错的选择。在官网上介绍是一个视图组，在相对位置显示子视图。是用于设计用户界面的非常强大的实用程序，因为它可以消除嵌套视图组并保持布局层次结构平坦，从而提高性能。如果您发现自己使用了多个嵌套组，则可以将它们替换为单个.
【Android从零单排系列三十】《Android布局介绍——RelativeLayout》
再见孙悟空的专栏
06-30 1649
小伙伴们，在上文中我们介绍了Android常见布局中的LinearLayout，本文我们继续盘点介绍Android开发中另一个常见的布局，相对布局RelativeLayout。RelativeLayout是Android中常用的布局容器，它基于相对位置来排列子视图，允许开发者以更灵活的方式组织界面布局。以下是对RelativeLayout的基本介绍：相对位置：RelativeLayout使用相对位置来定义子视图之间的关系。你可以通过在子视图的属性中指定相对于其他视图的位置进行布局，例如使用。
Android RelativeLayout实例+源码下载
03-16
摘要:Java源码,Android源码,相对布局,Android源码　Android RelativeLayout实例+源码下载，Android界面之相对布局的一个例子，安卓手机的界面都挺漂亮，那么究竟如何实现呢？这一方面和布局有很大关系，在布局中，...
Android应用源码之12.RelativeLayout.zip
12-04
这个"Android应用源码之12.RelativeLayout.zip"压缩包很可能是为了教学或研究目的，提供了一个使用RelativeLayout布局的实例代码。让我们深入探讨一下RelativeLayout及其在Android应用中的使用。 RelativeLayout是...
Android RelativeLayout相对布局属性简析
09-05
在Android应用开发中，界面设计是一项至关重要的任务，而RelativeLayou
Android 天气预报源码.zip
07-19
学习如何使用LinearLayout、RelativeLayout或ConstraintLayout等布局管理器来创建直观、响应式的用户界面是Android开发的基础。 3. **数据获取**：天气预报应用通常需要从网络获取实时天气数据。这涉及到HTTP请求的...
Android 医药助手源码.zip
07-19
Android使用HttpURLConnection、OkHttp或Volley等库进行网络请求，JSON解析库如Gson或Jackson用于解析服务器返回的数据。 6. **通知与提醒**：用药提醒功能可能涉及到AlarmManager或JobScheduler服务，它们可以按...
【Android】相对布局（RelativeLayout）最全解析
热门推荐
lucashu的博客
08-21 5万+
相对布局（RelativeLayout）是一种根据父容器和兄弟控件作为参照来确定控件位置的布局方式。使用相对布局，需要将布局节点改成
安卓开发入门教程-常用布局_RelativeLayout
蓝不蓝编程
09-04 523
关注 安卓007 ,免费获取全套安卓开发学习资料 什么是RelativeLayout RelativeLayout又称相对布局,是安卓开发中几个常用的布局之一,使用频率最高.支持相对于父控件或同级兄弟控件进行定位. 基础样例 1. 相对父控件定位 效果图 代码 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" an
Android入门教程 | UI布局之RelativeLayout 相对布局
Android23333的博客
09-28 2285
RelativeLayout 属性RelativeLayout 可以指定子视图相对于父视图或彼此（由 ID 确定）的位置。因此，可以按照右边框对齐两个元素，或者使它们一上一下，屏幕居中，左侧居中，等等。默认情况下，所有子视图均绘制在布局的左上角，因此必须使用 RelativeLayout.LayoutParams 中提供的各种布局属性定义每个视图的位置。如果为 “true”，会将此视图的上边缘与父视图的上边缘对齐。如果为 “true”，会将此子级在父级内垂直居中。
（五）Android布局类型（相对布局RelativeLayout）
以秘
03-16 1853
Android布局类型（相对布局RelativeLayout）
Android 移动开发 | Android 六大布局基础总结
go
09-15 3018
接下来进入Android 的入门基础知识,来了解Android中的布局.Android中有六大布局,其中分别是 RelativeLayout(相对布局)，LinearLayout(线性布局)，TableLayout(表格布局) ，FrameLayout(帧布局)，ConstraintLayout(约束布局)，GridLayout(网格布局) . 在实际的界面布局中我们最常用的是使用线性布局与相对布局结合使用,这个能达到较好的页面效果 RelativeLayout 相对布局 RelativeLayout相.
Android studio笔记:安卓基本开发布局（RelativeLayout）
薛定谔的猫
10-13 306
RelativeLayout相对布局，这个子容器是相对父容器，默认在左上；因为我们没有设置定位，因此第二个将第一个覆盖了。android:layout_marginLeft="100dp"是绿色容器跟父容器（黄色的）距离。android:layout_alignParentRight="true"相对父容器右对齐。android:layout_toRightOf="@+id/rl1"相对兄弟元素的右边。
android getChildAt(index)返回null问题解决方法
dijue6306的博客
12-11 761
　　getChildAt(index)方法ViewGroup类的方法，许多需要adapter的类（List,GridView）都可以使用这个方法。今天就用到了getChildAt(index)方法，我用的是GridView，需要在数据库中读出GridView中的某些项目，给这些子项替换背景（就是打个勾标记的背景），但是，却发现getChildAt(index)方法返回值一直为null，很...
Android开发之RelativeLayout
ShadyPi的IT笔记
03-11 1994
RelativeLayout，通过相对位置排布组件。
Android通讯录应用源码解析
这些布局文件使用了不同的布局组件，如LinearLayout、RelativeLayout和ListView，展示了如何在Android中创建用户界面。 - `Main.xml` 是应用的主要布局，可能包含了应用的主视图和导航菜单。 - `addnew.xml` 可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值