AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android自定义View——可以设置最大宽高的FrameLayout

2024-06-21 296
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Android自定义View——可以设置最大宽高的FrameLayout

在Android开发中，我们经常需要自定义View来满足特定的需求。其中，修改FrameLayout的高宽通常是一个常见的需求。本文将介绍如何自定义FrameLayout并修改其高宽。

FrameLayout简介

FrameLayout是Android中常用的布局容器之一，它可以包含多个子View，并按照它们在布局中的顺序进行叠加。每个子View可能会占据不同的位置和大小，但它们都会显示在FrameLayout的左上角。

自定义FrameLayout

要修改FrameLayout的高宽，我们可以自定义一个继承自FrameLayout的类，并在其中重写onMeasure方法。onMeasure方法用于测量子View的大小并设置布局容器的大小。

话不多说，直接上代码。

MaxLayout.java 

import android.util.DisplayMetrics;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.view.WindowManager;
 
 
/**
 *
 * 可以设置最大宽高的FrameLayout
 * 默认优先比例设置
 * 不支持参数小于零
 *
 */
public class MaxLayout extends FrameLayout {
    private float mMaxHeightRatio = -1f;// 优先级高
    private float mMaxHeight = -1f;// 优先级低
    private float mMaxWidthRatio = -1f;// 优先级高
    private float mMaxWidth = -1f;// 优先级低
    private int parentWidth;
    private int parentHeight;
    private boolean firstHeightRatio = true;//高默认优先比例设置
    private boolean firstWidthRatio = true;//宽默认优先比例设置
 
    public MaxLayout(Context context) {
        super(context);
    }
 
    public MaxLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        initAttrs(context, attrs);
    }
 
    public MaxLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        initAttrs(context, attrs);
    }
 
    private void initAttrs(Context context, AttributeSet attrs) {
        TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.MaxLayout);
        if(a!=null){
            firstHeightRatio = a.getBoolean(R.styleable.MaxLayout_first_ratio_height,true);
            firstWidthRatio = a.getBoolean(R.styleable.MaxLayout_first_ratio_width,true);
            mMaxHeightRatio = a.getFloat(R.styleable.MaxLayout_max_height_ratio, -1f);
            mMaxHeight = a.getDimension(R.styleable.MaxLayout_max_height, -1f);
            mMaxWidthRatio = a.getFloat(R.styleable.MaxLayout_max_width_ratio, -1f);
            mMaxWidth = a.getDimension(R.styleable.MaxLayout_max_width, -1f);
            a.recycle();
        }
    }
 
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        initParentWH();
        initWH();
 
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 
        int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize <= mMaxHeight ? heightSize : (int) mMaxHeight, heightMode);
 
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize <= mMaxWidth ? widthSize : (int) mMaxWidth, widthMode);
 
        super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
    }
 
    /**
     * 计算需要设置的宽高
     */
    private void initWH() {
        if((firstHeightRatio && mMaxHeightRatio > 0)
                || (!firstHeightRatio && mMaxHeight < 0)){
            mMaxHeight = mMaxHeightRatio * parentHeight;
        }
        if((firstWidthRatio && mMaxWidthRatio > 0)
                || (!firstWidthRatio && mMaxWidth < 0)){
            mMaxWidth = mMaxWidthRatio * parentWidth;
        }
    }
 
    /**
     * 获取父控件的宽高
     */
    private void initParentWH() {
        ViewGroup parent = (ViewGroup) getParent();
        if(null != parent){
            parentWidth = parent.getWidth();
            parentHeight = parent.getHeight();
        }else {
            WindowManager wm = (WindowManager) getContext()
                    .getSystemService(Context.WINDOW_SERVICE);
            DisplayMetrics dm = new DisplayMetrics();
            if (wm != null) {
                wm.getDefaultDisplay().getMetrics(dm);
                parentWidth = dm.widthPixels;
                parentHeight = dm.heightPixels;
            }
        }
    }
}

attrs.xml

    <declare-styleable name="MaxLayout">
        <attr name="max_height_ratio" format="float"/>
        <attr name="max_height" format="dimension"/>
        <attr name="max_width_ratio" format="float"/>
        <attr name="max_width" format="dimension"/>
        <attr name="first_ratio_height" format="boolean"/>
        <attr name="first_ratio_width" format="boolean"/>
    </declare-styleable>

在实际项目开发中，如果在Scrollview（也限定了宽高）中嵌套了限定宽高的Framelayout，可能会出现Framelayout里面的子view最底部的显示不出来的问题，那么就需要对上面的代码进行一定的改动。

思路：

  1. Framelayout 的高度应该是所有子view的高度的和；
  2. 由于Framelayout动态添加子view的时候如果不指定坐标的话或叠在一起，所以一般都会指定坐标；
  3. 对Framelayout里面的子view进行遍历，获取Y坐标最大的子view和该view的高度（也要考虑他的Margin值）；
  4. Framelayout 的高度实际上就是最大Y坐标的子view的高度+最大Y坐标的值。

同时也就解决了FrameLayout添加子view显示不全或者显示个数不完整的问题。

/**
 * 可以设置最大宽高的FrameLayout
 */
public class MaxFrameLayout extends FrameLayout {
 
    private static final String TAG = "MaxFrameLayout";
 
    private int mMaxHeight = 0;
    private int mMaxWidth = 0;
 
    public MaxFrameLayout(Context context) {
        super(context);
    }
 
    public MaxFrameLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
 
    public MaxFrameLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }
 
    public MaxFrameLayout(Context context, int maxWidth, int maxHeight) {
        super(context);
        mMaxWidth = maxWidth;
        mMaxHeight = maxHeight;
    }
 
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 
        int realHeight = Math.max(getParentHeight(getChildCount()), mMaxHeight);
        Log.e(TAG, "onMeasure  heightSize " + heightSize + " realHeight " + realHeight + "  mMaxHeight " + mMaxHeight);
 
        int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(Math.max(heightSize, realHeight), heightMode);
 
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(Math.min(widthSize, mMaxWidth), widthMode);
 
        super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
    }
 
    /**
     * 根据子view的坐标确定getParent的高度
     * @param size
     * @return
     */
    public int getParentHeight(int size) {
        int height = 0;
        int maxIndex = 0;
        int maxY = 0;//获取最底部view的Y坐标
        for (int i = 0; i < size; i++) {
            View child = getChildAt(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            int y = (int) child.getY();
            maxY = Math.max(y, maxY);
            if(maxY == y) {
                maxIndex = i;
                final int hPadding = lp.topMargin + lp.bottomMargin;
                height = maxY + lp.height + hPadding;
            }
            Log.d(TAG, "maxIndex " + maxIndex + " maxY " + maxY + " height " + height);
        }
        return height;
    }
 
 
}

其他实现方式。

一、自定义FrameLayout

public class CustomFrameLayout extends FrameLayout {
 
    public CustomFrameLayout(Context context) {
        super(context);
    }
 
    public CustomFrameLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
 
    public CustomFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
 
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 
        int width = 0;
        int height = 0;
 
        // 计算子View的宽度和高度
 
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            measureChild(child, widthMeasureSpec, heightMeasureSpec);
            width = Math.max(width, child.getMeasuredWidth());
            height = Math.max(height, child.getMeasuredHeight());
        }
 
        // 根据测量模式设置最终的宽度和高度
 
        if (widthMode == MeasureSpec.EXACTLY) {
            width = widthSize;
        } else if (widthMode == MeasureSpec.AT_MOST) {
            width = Math.min(width, widthSize);
        }
 
        if (heightMode == MeasureSpec.EXACTLY) {
            height = heightSize;
        } else if (heightMode == MeasureSpec.AT_MOST) {
            height = Math.min(height, heightSize);
        }
 
        // 设置最终的宽度和高度
 
        setMeasuredDimension(width, height);
    }
}

使用自定义FrameLayout

使用自定义的FrameLayout和使用普通的FrameLayout没有太大的区别，只需要在布局文件中使用我们定义的CustomFrameLayout即可。

<com.example.CustomFrameLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">
 
    <!-- 子View的布局 -->
 
</com.example.CustomFrameLayout>

二、自定义FrameLayout

GitHub - gdutxiaoxu/MaxLayout

MaxLayout.java

package com.xj.maxlayout;
 
import android.content.Context;
import android.content.res.TypedArray;
import android.support.annotation.IntDef;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.FrameLayout;
 
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
 
/**
 * This layout could set maxWidth,maxHeight,ratio
 * <p>
 * Created by jun xu on 19-2-1.
 */
public class MaxLayout extends FrameLayout {
 
    private static final String TAG = "MaxLayout";
    public static final float DEF_VALUE = -1f;
 
    public static final int W_H = 1;
    public static final int H_W = 2;
    public static final int STANDRAD = 0;
 
    private Context mContext;
 
    private float mMaxHeight = -1f;
    private float mMaxWidth = -1f;
 
    private @RatioStandrad
    int mRatioStandrad;
    private float mRatio;
 
    @IntDef({STANDRAD, W_H, H_W})
    @Retention(RetentionPolicy.SOURCE)
    public @interface RatioStandrad {
    }
 
    public MaxLayout(Context context) {
        this(context, null, 0);
    }
 
    public MaxLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
 
    public MaxLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        mContext = context;
        initAttrs(attrs);
    }
 
    private void initAttrs(AttributeSet attrs) {
        TypedArray ta = mContext.obtainStyledAttributes(attrs, R.styleable.MaxLayout);
        mMaxHeight = ta.getDimension(R.styleable.MaxLayout_ml_maxheight, DEF_VALUE);
        mMaxWidth = ta.getDimension(R.styleable.MaxLayout_ml_maxWidth, DEF_VALUE);
        mRatioStandrad = ta.getInt(R.styleable.MaxLayout_ml_ratio_standard, STANDRAD);
        mRatio = ta.getFloat(R.styleable.MaxLayout_ml_ratio, 0);
 
        ta.recycle();
    }
 
    public void setMaxHeight(float maxHeight) {
        mMaxHeight = maxHeight;
    }
 
    public void setMaxWidth(float maxWidth) {
        mMaxWidth = maxWidth;
    }
 
    public void setRatioStandrad(int ratioStandrad) {
        mRatioStandrad = ratioStandrad;
    }
 
    /**
     * only mRatioStandrad is {@link #W_H, #H_W},this is effective
     *
     * @param ratio
     */
    public void setRatio(float ratio) {
        mRatio = ratio;
    }
 
    public float getMaxHeight() {
        return mMaxHeight;
    }
 
    public float getMaxWidth() {
        return mMaxWidth;
    }
 
    public int getRatioStandrad() {
        return mRatioStandrad;
    }
 
    public float getRatio() {
        return mRatio;
    }
 
    public void clearMaxWidthFlag() {
        mMaxWidth = -1f;
    }
 
    public void clearMaxHeightFlag() {
        mMaxHeight = -1f;
    }
 
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        // 是否设置了比例
        boolean setRatio = isSetRatio();
        // 没有设置最大宽度，高度，宽高比例，不需要调整，直接返回
        if (mMaxWidth <= DEF_VALUE && mMaxHeight <= DEF_VALUE && !setRatio) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            return;
        }
 
        // 拿到原来宽度，高度的 mode 和 size
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
 
        Log.d(TAG, "origin onMeasure: widthSize =" + widthSize + "heightSize = " + heightSize);
 
        if (mRatioStandrad == W_H) { // 当模式已宽度为基准
            widthSize = getWidth(widthSize);
 
            if (mRatio >= 0) {
                heightSize = (int) (widthSize * mRatio);
 
            }
 
            heightSize = getHeight(heightSize);
            int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY);
            int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
            super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
        } else if (mRatioStandrad == H_W) { // 当模式已高度为基准
            heightSize = getHeight(heightSize);
 
            if (mRatio >= 0) {
                widthSize = (int) (heightSize * mRatio);
            }
 
            widthSize = getWidth(widthSize);
 
            int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
            int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, MeasureSpec.EXACTLY);
            super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
        } else { // 当没有设定比例的时候
            widthSize = getWidth(widthSize);
            heightSize = getHeight(heightSize);
            int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
            int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
            super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
        }
 
        Log.d(TAG, "adjust onMeasure: widthSize =" + widthSize + "heightSize = " + heightSize);
 
    }
 
    // 对宽度进行调整，是否超出最大宽度，超出取最大宽度，没超出，取原来的值
    private int getWidth(int widthSize) {
        if (mMaxWidth <= DEF_VALUE) {
            return widthSize;
        }
 
        return widthSize <= mMaxWidth ? widthSize : (int) mMaxWidth;
    }
 
    // 对高度进行调整，是否超出最大高度，超出取最大高度，没超出，取原来的值
    private int getHeight(int heightSize) {
        if (mMaxHeight <= DEF_VALUE) {
            return heightSize;
        }
        return heightSize <= mMaxHeight ? heightSize : (int) mMaxHeight;
    }
 
    private boolean isSetRatio() {
        return mRatio > 0f && (mRatioStandrad == W_H || mRatioStandrad == H_W);
    }
 
}

使用说明

常用的自定义属性

<declare-styleable> 
   <attr name="ml_maxWidth" format="dimension" />
    <attr name="ml_maxheight" format="dimension" />
    <attr name="ml_ratio" format="float" />
    <attr name="ml_ratio_standard">
        <enum name="w_h" value="1" />
        <enum name="h_w" value="2" />
    </attr>
</declare-styleable>

指定最大宽度，高度

指定最大宽度，最大高度，我们值需要使用 ml_maxWidth，ml_maxheight 属性即可，当然我们也可以同时指定最大宽度和最大高度。如下

<com.xj.maxlayout.MaxLayout
    android:layout_width="match_parent"
    android:layout_height="100dp"
    android:layout_marginTop="15dp"
    android:background="@android:color/holo_blue_light"
    app:ml_maxWidth="200dp">
 
    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:padding="10dp"
        android:text="指定最大宽度,指定最大宽度,指定最大宽度" />
 
</com.xj.maxlayout.MaxLayout>
 
<com.xj.maxlayout.MaxLayout
    android:layout_width="200dp"
    android:layout_height="match_parent"
    android:layout_marginTop="15dp"
    android:background="@android:color/holo_blue_light"
    app:ml_maxheight="200dp">
 
    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center"
        android:gravity="center"
        android:padding="10dp"
        android:text="指定最大高度" />
 
</com.xj.maxlayout.MaxLayout>
 
<com.xj.maxlayout.MaxLayout
    android:layout_width="wrap_content"
    android:layout_height="match_parent"
    android:layout_marginTop="15dp"
    android:background="@android:color/holo_blue_light"
    app:ml_maxWidth="200dp"
    app:ml_maxheight="150dp">
 
    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:padding="10dp"
        android:text="同时指定最大宽度和最大高度" />
 
</com.xj.maxlayout.MaxLayout>

指定宽高比

指定宽高比，我们需要设置两个属性，ml_ratio_standard 和 ml_ratio。ml_ratio_standard 有两个值，w_h 代表已宽度为基准，h_w 代表已高度为基准。

<com.xj.maxlayout.MaxLayout
    android:id="@+id/ml_1"
    android:layout_width="100dp"
    android:layout_height="wrap_content"
    android:background="@color/colorAccent"
    app:ml_ratio="2.0"
    app:ml_ratio_standard="w_h">
 
    <ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="centerCrop"
        android:src="@mipmap/jsy03" />
 
 
</com.xj.maxlayout.MaxLayout>

比如，我们要指定宽度是高度的某个比例的时候，如，宽度是高度的 0.8，可以这样写

<com.xj.maxlayout.MaxLayout
    android:id="@+id/ml_2"
    android:layout_width="match_parent"
    android:layout_height="200dp"
    android:layout_marginLeft="20dp"
    android:layout_toRightOf="@id/ml_1"
    android:background="@android:color/holo_blue_light"
    app:ml_ratio="0.8"
    app:ml_ratio_standard="h_w">
 
    <ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="centerCrop"
        android:src="@mipmap/jsy04" />
 
</com.xj.maxlayout.MaxLayout>

当然，也可以同时指定比例和最大宽度，高度。

<com.xj.maxlayout.MaxLayout
    android:id="@+id/ml_03"
    android:layout_width="match_parent"
    android:layout_height="220dp"
    android:layout_below="@id/ml_1"
    android:layout_marginTop="15dp"
    android:background="@android:color/holo_blue_light"
    app:ml_maxWidth="150dp">
 
    <ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:scaleType="centerCrop"
        android:src="@mipmap/jsy05" />
 
</com.xj.maxlayout.MaxLayout>

原理介绍

原理其实很简单，对自定义 View 有基本了解的人都知道，View 的宽度和高度，是在 onMeasure 方法中进行测量的，他们的大小受 MeasureSpec 的影响。既然如此，那么我们在继承 FrameLayout，重写它的 onMeasure 方法。在 onMeasure 方法中根据我们指定的最大宽度，高度和比例对 MeasureSpec 进行调整即可。

思路大概如下

  • 没有设置最大宽度，高度，宽高比例，不需要调整，直接返回
  • 先拿到原来的 mode 和 size，暂存起来
  • 根据宽高的比例进行相应的调整
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    // 是否设置了比例
    boolean setRatio = isSetRatio();
    // 没有设置最大宽度，高度，宽高比例，不需要调整，直接返回
    if (mMaxWidth <= DEF_VALUE && mMaxHeight <= DEF_VALUE && !setRatio) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        return;
    }
 
    // 拿到原来宽度，高度的 mode 和 size
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
 
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
 
    Log.d(TAG, "origin onMeasure: widthSize =" + widthSize + "heightSize = " + heightSize);
 
    if (mRatioStandrad == W_H) { // 当模式已宽度为基准
        widthSize = getWidth(widthSize);
 
        if (mRatio >= 0) {
            heightSize = (int) (widthSize * mRatio);
        }
 
        heightSize = getHeight(heightSize);
        int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY);
        int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
        super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
    } else if (mRatioStandrad == H_W) { // 当模式已高度为基准
        heightSize = getHeight(heightSize);
 
        if (mRatio >= 0) {
            widthSize = (int) (heightSize * mRatio);
        }
 
        widthSize = getWidth(widthSize);
 
        int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
        int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, MeasureSpec.EXACTLY);
        super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
    } else { // 当没有设定比例的时候
        widthSize = getWidth(widthSize);
        heightSize = getHeight(heightSize);
        int maxHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
        int maxWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
        super.onMeasure(maxWidthMeasureSpec, maxHeightMeasureSpec);
 
    }
 
    Log.d(TAG, "adjust onMeasure: widthSize =" + widthSize + "heightSize = " + heightSize);
    
}

我们来看一下，有三种模式：

  1. 当模式已宽度为基准的时候，我们首先对宽度进行调整，是否超出最大宽度，超出取最大宽度，没超出，取原来的值。接着，高度按照 mRatio 进行调整，接着判断高度是否超出最大高度，超出取最大高度，没超出，取原来的值。最后，根据相应的 size，mode 生成相应的 MeasureSpec
  2. 当模式已高度为基准的时候，我们首先对高度进行调整，是否超出最大高度，超出取最大高度，没超出，取原来的值。接着，宽度按照 mRatio 进行调整，接着判断宽度是否超出最大宽度，超出取最大宽度，没超出，取原来的值。最后，根据相应的 size，mode 生成相应的 MeasureSpec
  3. 当模式是默认，没有指定宽度或者高度作为基准的时候，直接判断宽高度是否超出最大的宽高度，制定相应的 MeasureSpec 即可。

三、自定义FrameLayout

完整项目示例Git仓库

CustomFrameLayout: The CustomMaxSizeFrameLayout extends FrameLayout can make its child have the custom attribute maxWidth and maxHeight.

package com.example.jokerlee.custommaxsizeframelayout;
 
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.ViewDebug;
import android.view.ViewGroup;
import android.widget.FrameLayout;
 
/**
 * Created by jokerlee on 16-3-14.
 */
public class CustomFramlayout extends FrameLayout {
 
    private static final String TAG = "CustomFramlayout";
    private static final boolean DEBUG = false;
 
    public CustomFramlayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
 
    @Override
    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new LayoutParams(getContext(),attrs);
    }
 
    @Override
    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
        return p instanceof LayoutParams ? new LayoutParams((LayoutParams)p):new LayoutParams(p);
    }
 
    @Override
    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
        return p instanceof LayoutParams;
    }
 
    @Override
    protected void onMeasure(int widthSpec, int heightSpec) {
        final int widthMode = MeasureSpec.getMode(widthSpec);
        final int heightMode = MeasureSpec.getMode(heightSpec);
        if (DEBUG && widthMode != MeasureSpec.AT_MOST) {
            Log.w(TAG, "onMeasure: widthSpec " + MeasureSpec.toString(widthSpec) +
                    " should be AT_MOST");
        }
        if (DEBUG && heightMode != MeasureSpec.AT_MOST) {
            Log.w(TAG, "onMeasure: heightSpec " + MeasureSpec.toString(heightSpec) +
                    " should be AT_MOST");
        }
 
        final int widthSize = MeasureSpec.getSize(widthSpec);
        final int heightSize = MeasureSpec.getSize(heightSpec);
        int maxWidth = widthSize;
        int maxHeight = heightSize;
        final int count = getChildCount();
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
 
            if (lp.maxWidth > 0 && lp.maxWidth < maxWidth) {
                maxWidth = lp.maxWidth;
            }
            if (lp.maxHeight > 0 && lp.maxHeight < maxHeight) {
                maxHeight = lp.maxHeight;
            }
        }
 
        final int wPadding = getPaddingLeft() + getPaddingRight();
        final int hPadding = getPaddingTop() + getPaddingBottom();
        maxWidth -= wPadding;
        maxHeight -= hPadding;
 
        int width = widthMode == MeasureSpec.EXACTLY ? widthSize : 0;
        int height = heightMode == MeasureSpec.EXACTLY ? heightSize : 0;
        for (int i = 0; i < count; i++) {
            final View child = getChildAt(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
 
            final int childWidthSpec = makeChildMeasureSpec(maxWidth, lp.width);
            final int childHeightSpec = makeChildMeasureSpec(maxHeight, lp.height);
 
            child.measure(childWidthSpec, childHeightSpec);
 
            width = Math.max(width, Math.min(child.getMeasuredWidth(), widthSize - wPadding));
            height = Math.max(height, Math.min(child.getMeasuredHeight(), heightSize - hPadding));
        }
        setMeasuredDimension(width + wPadding, height + hPadding);
    }
 
    private int makeChildMeasureSpec(int maxSize, int childDimen) {
        final int mode;
        final int size;
        switch (childDimen) {
            case LayoutParams.WRAP_CONTENT:
                mode = MeasureSpec.AT_MOST;
                size = maxSize;
                break;
            case LayoutParams.MATCH_PARENT:
                mode = MeasureSpec.EXACTLY;
                size = maxSize;
                break;
            default:
                mode = MeasureSpec.EXACTLY;
                size = Math.min(maxSize, childDimen);
                break;
        }
        return MeasureSpec.makeMeasureSpec(size, mode);
    }
 
    public static class LayoutParams extends FrameLayout.LayoutParams {
        @ViewDebug.ExportedProperty(category = "layout")
        public int maxWidth;
 
        @ViewDebug.ExportedProperty(category = "layout")
        public int maxHeight;
 
        public LayoutParams(ViewGroup.LayoutParams other) {
            super(other);
        }
 
        public LayoutParams(LayoutParams other) {
            super(other);
 
            maxWidth = other.maxWidth;
            maxHeight = other.maxHeight;
        }
 
        public LayoutParams(Context c, AttributeSet attrs) {
            super(c, attrs);
 
            final TypedArray a = c.obtainStyledAttributes(attrs,
                    R.styleable.CustomFrameLayoutAttr, 0, 0);
            maxWidth = a.getDimensionPixelSize(
                    R.styleable.CustomFrameLayoutAttr_layout_maxWidth, 0);
            maxHeight = a.getDimensionPixelSize(
                    R.styleable.CustomFrameLayoutAttr_layout_maxHeight, 0);
            a.recycle();
        }
    }
}

使用:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:custom_attr="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.jokerlee.custommaxsizeframelayout.MainActivity">
 
    <com.example.jokerlee.custommaxsizeframelayout.CustomFramlayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
 
        <FrameLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            custom_attr:layout_maxWidth="50dp"
            custom_attr:layout_maxHeight="30dp">
 
            <ImageView
                android:layout_width="350dp"
                android:layout_height="330dp"
                android:layout_gravity="center"
                android:background="@color/material_blue_grey_800"/>
 
        </FrameLayout>
    </com.example.jokerlee.custommaxsizeframelayout.CustomFramlayout>
 
</RelativeLayout>

attrs.xml 

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <declare-styleable name="CustomFrameLayoutAttr">
        <attr name="layout_maxWidth" format="dimension"/>
        <attr name="layout_maxHeight" format="dimension"/>
    </declare-styleable>
</resources>


文章标签：
Android开发
容器
开发工具
git
关键词：
Android设置
Android自定义
Android View
Android自定义View
Android FrameLayout
一叶飘舟
目录
相关文章
shuj
|
1月前
|
缓存 前端开发 Android开发
安卓开发中的自定义视图：从零到英雄
【10月更文挑战第42天】 在安卓的世界里，自定义视图是一块画布，让开发者能够绘制出独一无二的界面体验。本文将带你走进自定义视图的大门，通过深入浅出的方式，让你从零基础到能够独立设计并实现复杂的自定义组件。我们将探索自定义视图的核心概念、实现步骤，以及如何优化你的视图以提高性能和兼容性。准备好了吗？让我们开始这段创造性的旅程吧！
shuj
28 1
shuj
|
2月前
|
数据可视化 Android开发 开发者
安卓应用开发中的自定义View组件
【10月更文挑战第5天】在安卓应用开发中，自定义View组件是提升用户交互体验的利器。本篇将深入探讨如何从零开始创建自定义View，包括设计理念、实现步骤以及性能优化技巧，帮助开发者打造流畅且富有创意的用户界面。
shuj
107 0
蓝易云
|
1月前
|
XML 前端开发 Android开发
Android：UI：Drawable：View/ImageView与Drawable
通过本文的介绍，我们详细探讨了Android中Drawable、View和ImageView的使用方法及其相互关系。Drawable作为图像和图形的抽象表示，提供了丰富的子类和自定义能力，使得开发者能够灵活地实现各种UI效果。View和ImageView则通过使用Drawable实现了各种图像和图形的显示需求。希望本文能为您在Android开发中使用Drawable提供有价值的参考和指导。
蓝易云
42 2
天下无贼001
|
1月前
|
搜索推荐 前端开发 Android开发
安卓应用开发中的自定义视图实现
【10月更文挑战第30天】在安卓开发的海洋中，自定义视图是那抹不可或缺的亮色，它为应用界面的个性化和交互体验的提升提供了无限可能。本文将深入探讨如何在安卓平台创建自定义视图，并展示如何通过代码实现这一过程。我们将从基础出发，逐步引导你理解自定义视图的核心概念，然后通过一个实际的代码示例，详细讲解如何将理论应用于实践，最终实现一个美观且具有良好用户体验的自定义控件。无论你是想提高自己的开发技能，还是仅仅出于对安卓开发的兴趣，这篇文章都将为你提供价值。
天下无贼001
43 4
shuj
|
1月前
|
Android开发 开发者 UED
安卓开发中自定义View的实现与性能优化
【10月更文挑战第28天】在安卓开发领域，自定义View是提升应用界面独特性和用户体验的重要手段。本文将深入探讨如何高效地创建和管理自定义View，以及如何通过代码和性能调优来确保流畅的交互体验。我们将一起学习自定义View的生命周期、绘图基础和事件处理，进而探索内存和布局优化技巧，最终实现既美观又高效的安卓界面。
shuj
41 5
大树营养快线
|
2月前
|
缓存 数据处理 Android开发
在 Android 中使用 RxJava 更新 View
【10月更文挑战第20天】使用 RxJava 来更新 View 可以提供更优雅、更高效的解决方案。通过合理地运用操作符和订阅机制，我们能够轻松地处理异步数据并在主线程中进行 View 的更新。在实际应用中，需要根据具体情况进行灵活运用，并注意相关的注意事项和性能优化，以确保应用的稳定性和流畅性。可以通过不断的实践和探索，进一步掌握在 Android 中使用 RxJava 更新 View 的技巧和方法，为开发高质量的 Android 应用提供有力支持。
大树营养快线
18 2
mao29955
|
2月前
|
缓存 调度 Android开发
Android 在子线程更新 View
【10月更文挑战第21天】在 Android 开发中，虽然不能直接在子线程更新 View，但通过使用 Handler、AsyncTask 或 RxJava 等方法，可以实现子线程操作并在主线程更新 View 的目的。在实际应用中，需要根据具体情况选择合适的方法，并注意相关的注意事项和性能优化，以确保应用的稳定性和流畅性。可以通过不断的实践和探索，进一步掌握在子线程更新 View 的技巧和方法，为开发高质量的 Android 应用提供支持。
mao29955
43 2
游客syv66y3m2ksnc
|
2月前
|
XML 前端开发 Android开发
Android面试高频知识点(3) 详解Android View的绘制流程
Android面试高频知识点(3) 详解Android View的绘制流程
游客syv66y3m2ksnc
25 0
Android面试高频知识点(3) 详解Android View的绘制流程
悟道了凡
|
2月前
|
XML 前端开发 Android开发
Android面试高频知识点(3) 详解Android View的绘制流程
Android面试高频知识点(3) 详解Android View的绘制流程
悟道了凡
29 2
stefanie燕
|
2月前
|
XML 前端开发 Android开发
Android View的绘制流程和原理详细解说
Android View的绘制流程和原理详细解说
stefanie燕
55 3

热门文章

最新文章

  • 1
    深入探索Android系统架构：从内核到应用层的全面解析
  • 2
    探索安卓系统的最新特性与发展趋势
  • 3
    Android系统版本演进：从1.0到最新，见证移动操作系统的蜕变####
  • 4
    深入探索Android系统的内存管理机制
  • 5
    安卓与iOS开发中的线程管理差异解析
  • 6
    探索安卓开发：打造你的第一款应用
  • 7
    移动应用开发之旅：探索Android和iOS平台
  • 8
    探索安卓开发：打造你的首个天气应用
  • 9
    安卓与iOS开发中的跨平台策略：一次编码，多平台部署
  • 10
    探索Android系统的最新安全特性
  • 1
    构建高效Android应用：探究Kotlin协程的优化实践
    61
  • 2
    鸿蒙HarmonyOS 与 Android 的NDK有什么区别？
    420
  • 3
    Android应用开发：实现自定义View的高效绘制
    81
  • 4
    构建高效Android应用：Kotlin协程的实践与优化
    73
  • 5
    构建高效Android应用：Kotlin协程的实践指南
    81
  • 6
    jenkins编译H5做的android端编译卫士app记录
    59
  • 7
    利用Bundle实现Android Activity间消息的传递
    61
  • 8
    Intent在Android中的几种用法
    95
  • 9
    Android如何在Activity和Service之间传递数据
    317
  • 10
    android TextView HTML 的效果
    49

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline

    • 推荐镜像

    更多
  • android.googlesource.com
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)