Authorative way to override onMeasure()?

Question

What's the correct way of overriding onMeasure()? I've seen various approaches. For example, Professional Android Development uses MeasureSpec to calculate the dimensions, then ends with a call to setMeasuredDimension(). For example:

@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
int parentHeight = MeasureSpec.getSize(heightMeasureSpec);
this.setMeasuredDimension(parentWidth/2, parentHeight);
}

On the other hand, as per this post, the "correct" way is to use MeasureSpec, call setMeasuredDimensions(), followed by a call to setLayoutParams(), and ending with a call to super.onMeasure(). For example:

@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec){
int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
int parentHeight = MeasureSpec.getSize(heightMeasureSpec);
this.setMeasuredDimension(parentWidth/2, parentHeight);
this.setLayoutParams(new *ParentLayoutType*.LayoutParams(parentWidth/2,parentHeight));
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

So which is the right way? Neither approach has worked 100% for me.

I guess really what I'm asking is does anyone know of a tutorial that explains onMeasure(), layout, dimensions of child views etc.?

did you find the answer useful/ correct? why not mark it as *the* answer? — superjos, Dec 01 '11 at 18:38

Grimmace · Answer 1 · 2013-08-14T22:30:47.880

The other solutions are not comprehensive. They may work in some cases, and are a good place to start, but they may are not guaranteed to work.

When onMeasure gets called you may or may not have the rights to change the size. The values that are passed to your onMeasure (widthMeasureSpec, heightMeasureSpec) contain information about what your child view is allowed to do. Currently there are three values:

MeasureSpec.UNSPECIFIED - You can be as big as you'd like
MeasureSpec.AT_MOST - As big as you want (up to the spec size), This is parentWidth in your example.
MeasureSpec.EXACTLY - No choice. Parent has chosen.

This is done so that Android can make multiple passes to find the right size for each item, see here for more details.

If you do not follow these rules, your approach is not guaranteed to work.

For example if you want to check if you're allowed to change the size at all you can do the following:

final int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
final int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
boolean resizeWidth = widthSpecMode != MeasureSpec.EXACTLY;
boolean resizeHeight = heightSpecMode != MeasureSpec.EXACTLY;

Using this information you will know whether you can modify the values as in your code. Or if you are required to do something different. A quick and easy way to resolve your desired size is to use one of the following methods:

int resolveSizeAndState (int size, int measureSpec, int childMeasuredState)

int resolveSize (int size, int measureSpec)

While the first is only available on Honeycomb, the second is available on all versions.

Note: You may find that resizeWidth or resizeHeight are always false. I found this to be the case if I was requesting MATCH_PARENT. I was able to fix this by requesting WRAP_CONTENT on my parent layout and then during the UNSPECIFIED phase requesting a size of Integer.MAX_VALUE. Doing so gives you the max size your parent allows on the next pass through onMeasure.

satur9nine · Answer 2 · 2011-11-15T07:28:25.290

39

The documentation is the authority on this matter: http://developer.android.com/guide/topics/ui/how-android-draws.html and http://developer.android.com/guide/topics/ui/custom-components.html

To summarize: at the end of your overridden onMeasure method you should call setMeasuredDimension.

You should not call super.onMeasure after calling setMeasuredDimension, that will just erase whatever you set. In some situations you might want to call the super.onMeasure first and then modify the results by calling setMeasuredDimension.

Don't call setLayoutParams in onMeasure. Layout happens in a second pass after measuring.

edited Nov 15 '11 at 07:28

answered Oct 20 '11 at 18:45

satur9nine

13,927
5
80
123

My experience is that if I override onMeasure without calling super.onMeasure, OnLayout is not called on child views. – William Jockusch Jun 11 '14 at 01:24

YON · Answer 3 · 2023-07-27T02:30:57.230

I think it depends on the parent which you are overriding.

For example, if you are extending a ViewGroup (like FrameLayout), when you have measured the size, you should call like below

super.onMeasure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));

because you may want ViewGroup to do rest works (do some stuffs on child views)

If you are extending a View (like ImageView), you can just call this.setMeasuredDimension(width, height);, because the parent class will just do something like you have done usually.

In a word, if you want some features your parent class offers free, you should call super.onMeasure() (pass MeasureSpec.EXACTLY mode measure spec usually), otherwise call this.setMeasuredDimension(width, height); is enough.

score 0 · Answer 4 · answered Jan 27 '13 at 22:59

0

If changing the views size inside of onMeasure all you need is the setMeasuredDimension call. If you are changing the size outside of onMeasure you need to call setLayoutParams. For instance changing the size of a text view when the text is changed.

answered Jan 27 '13 at 22:59

Kyle O.

376
2
7

You can still call setMinWidth() and setMaxWidth() and have the standard onMeasure handle it. I have found that it better to not call setLayoutParams from inside of a custom View class. It is really used for ViewGroups or Activities to override child view behavior. – Dorrin May 01 '14 at 20:40

score 0 · Answer 5 · answered May 19 '13 at 06:21

Depends on the control you are using. The instructions in the documentation work for some controls (TextView, Button, ...), but not for others (LinearLayout, ...). The way that worked very well for me was to call the super once I am done. Based on the article in the below link.

http://humptydevelopers.blogspot.in/2013/05/android-view-overriding-onmeasure.html

score 0 · Answer 6 · answered Aug 20 '14 at 07:31

0

here is how I solved the problem:

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        ....

        setMeasuredDimension( measuredWidth, measuredHeight );

        widthMeasureSpec = MeasureSpec.makeMeasureSpec( measuredWidth, MeasureSpec.EXACTLY );
        heightMeasureSpec = MeasureSpec.makeMeasureSpec( measuredHeight, MeasureSpec.EXACTLY);

        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

}

Moreover it was necessary for the ViewPager component

answered Aug 20 '14 at 07:31

Yuli Reiri

591
7
18

3

This is not proper solution. `super.onMeasure` will clear the dimensions set using `setMeasuredDimension`. – tomrozb Apr 04 '15 at 10:23
@tomrozb it's not http://www.humptydevelopers.com/2013/05/android-view-overriding-onmeasure.html and you can check android sources – Yuli Reiri Apr 16 '15 at 09:16
@YuliReiri: Perfect solution ! – Shayan Tabatabaee Dec 19 '19 at 21:30

score -1 · Answer 7 · answered Dec 21 '11 at 14:51

I guess, setLayoutParams and recalculating the measurements is a workaround to resize the child views correctly, as this is usually done in the derived class's onMeasure.

However, this rarely works correct (for whatever reason...), better invoke measureChildren (when deriving a ViewGroup) or try something similar when necessary.

score -5 · Answer 8 · edited Mar 23 '15 at 12:37

you can take this piece of code as an example of onMeasure()::

public class MyLayerLayout extends RelativeLayout {

    public MyLayerLayout(Context context) {
        super(context);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
        int parentHeight = MeasureSpec.getSize(heightMeasureSpec);

        int currentChildCount = getChildCount();
        for (int i = 0; i < currentChildCount; i++) {
            View currentChild = getChildAt(i);

            //code to find information

            int widthPercent = currentChildInfo.getWidth();
            int heightPercent = currentChildInfo.getHeight();

//considering we will pass height & width as percentage

            int myWidth = (int) Math.round(parentWidth * (widthPercent / 100.0));
            int myHeight = (int) Math.round(parentHeight * (heightPercent / 100.0));

//Considering we need to set horizontal & vertical position of the view in parent

            AlignmentTraitValue vAlign = currentChildInfo.getVerticalLocation() != null ? currentChildlayerInfo.getVerticalLocation() : currentChildAlignmentTraitValue.TOP;
            AlignmentTraitValue hAlign = currentChildInfo.getHorizontalLocation() != null ? currentChildlayerInfo.getHorizontalLocation() : currentChildAlignmentTraitValue.LEFT;
            int topPadding = 0;
            int leftPadding = 0;

            if (vAlign.equals(currentChildAlignmentTraitValue.CENTER)) {
                topPadding = (parentHeight - myHeight) / 2;
            } else if (vAlign.equals(currentChildAlignmentTraitValue.BOTTOM)) {
                topPadding = parentHeight - myHeight;
            }

            if (hAlign.equals(currentChildAlignmentTraitValue.CENTER)) {
                leftPadding = (parentWidth - myWidth) / 2;
            } else if (hAlign.equals(currentChildAlignmentTraitValue.RIGHT)) {
                leftPadding = parentWidth - myWidth;
            }
            LayoutParams myLayoutParams = new LayoutParams(myWidth, myHeight);
            currentChildLayoutParams.setMargins(leftPadding, topPadding, 0, 0);
            currentChild.setLayoutParams(myLayoutParams);
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }
}

This code is fundamentally wrong. First, it doesn't take the layout mode into account (see Grimmace's answer). That's bad but you won't see the effect of that because you also call super.onMeasure() at the very end, which overrides the values you set (see satur9nine's answer) and defeats the purpose of overriding onMeasure() at all. — spaaarky21, Feb 11 '13 at 17:51

Authorative way to override onMeasure()?

8 Answers8

Linked