本文是对ViewGroup的源码分析，先来看看关系结构
| java.lang.Object | ||
| ↳ | android.view.View | |
| ↳ | android.view.ViewGroup | |
概述
A ViewGroup is a special view that can contain other views (called children.) The view group is the base class for layouts and views containers. This class also defines the ViewGroup.LayoutParams class which serves as the base class for layouts parameters.
首先ViewGroup是一个抽象类，它继承子View，实现了两个重要接口：ViewManager、ViewParent，这两个接口中分别包含着极为重要的方法，可以说代表了ViewGroup的核心特性。
1.ViewManager.java接口源码：
public interface ViewManager
{
/**
* Assign the passed LayoutParams to the passed View and add the view to the window.
* <p>Throws {@link android.view.WindowManager.BadTokenException} for certain programming
* errors, such as adding a second view to a window without removing the first view.
* <p>Throws {@link android.view.WindowManager.InvalidDisplayException} if the window is on a
* secondary {@link Display} and the specified display can't be found
* (see {@link android.app.Presentation}).
* @param view The view to be added to this window.
* @param params The LayoutParams to assign to view.
*/
public void addView(View view, ViewGroup.LayoutParams params);
public void updateViewLayout(View view, ViewGroup.LayoutParams params);
public void removeView(View view);
}2. ViewParent.java接口源码：
/**
* Called when something has changed which has invalidated the layout of a
* child of this view parent. This will schedule a layout pass of the view
* tree.
*/
public void requestLayout();
/**
* Indicates whether layout was requested on this view parent.
*
* @return true if layout was requested, false otherwise
*/
public boolean isLayoutRequested();
/**
* Called when a child wants the view hierarchy to gather and report
* transparent regions to the window compositor. Views that "punch" holes in
* the view hierarchy, such as SurfaceView can use this API to improve
* performance of the system. When no such a view is present in the
* hierarchy, this optimization in unnecessary and might slightly reduce the
* view hierarchy performance.
*
* @param child the view requesting the transparent region computation
*
*/
public void requestTransparentRegion(View child);
/**
* All or part of a child is dirty and needs to be redrawn.
*
* @param child The child which is dirty
* @param r The area within the child that is invalid
*/
public void invalidateChild(View child, Rect r);
/**
* All or part of a child is dirty and needs to be redrawn.
*
* <p>The location array is an array of two int values which respectively
* define the left and the top position of the dirty child.</p>
*
* <p>This method must return the parent of this ViewParent if the specified
* rectangle must be invalidated in the parent. If the specified rectangle
* does not require invalidation in the parent or if the parent does not
* exist, this method must return null.</p>
*
* <p>When this method returns a non-null value, the location array must
* have been updated with the left and top coordinates of this ViewParent.</p>
*
* @param location An array of 2 ints containing the left and top
* coordinates of the child to invalidate
* @param r The area within the child that is invalid
*
* @return the parent of this ViewParent or null
*/
public ViewParent invalidateChildInParent(int[] location, Rect r);
/**
* Returns the parent if it exists, or null.
*
* @return a ViewParent or null if this ViewParent does not have a parent
*/
public ViewParent getParent();
/**
* Called when a child of this parent wants focus
*
* @param child The child of this ViewParent that wants focus. This view
* will contain the focused view. It is not necessarily the view that
* actually has focus.
* @param focused The view that is a descendant of child that actually has
* focus
*/
public void requestChildFocus(View child, View focused);
/**
* Tell view hierarchy that the global view attributes need to be
* re-evaluated.
*
* @param child View whose attributes have changed.
*/
public void recomputeViewAttributes(View child);
/**
* Called when a child of this parent is giving up focus
*
* @param child The view that is giving up focus
*/
public void clearChildFocus(View child);
/**
* Compute the visible part of a rectangular region defined in terms of a child view's
* coordinates.
*
* <p>Returns the clipped visible part of the rectangle <code>r</code>, defined in the
* <code>child</code>'s local coordinate system. <code>r</code> is modified by this method to
* contain the result, expressed in the global (root) coordinate system.</p>
*
* <p>The resulting rectangle is always axis aligned. If a rotation is applied to a node in the
* View hierarchy, the result is the axis-aligned bounding box of the visible rectangle.</p>
*
* @param child A child View, whose rectangular visible region we want to compute
* @param r The input rectangle, defined in the child coordinate system. Will be overwritten to
* contain the resulting visible rectangle, expressed in global (root) coordinates
* @param offset The input coordinates of a point, defined in the child coordinate system.
* As with the <code>r</code> parameter, this will be overwritten to contain the global (root)
* coordinates of that point.
* A <code>null</code> value is valid (in case you are not interested in this result)
* @return true if the resulting rectangle is not empty, false otherwise
*/
public boolean getChildVisibleRect(View child, Rect r, android.graphics.Point offset);
/**
* Find the nearest view in the specified direction that wants to take focus
*
* @param v The view that currently has focus
* @param direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
*/
public View focusSearch(View v, int direction);
/**
* Change the z order of the child so it's on top of all other children.
* This ordering change may affect layout, if this container
* uses an order-dependent layout scheme (e.g., LinearLayout). This
* method should be followed by calls to {@link #requestLayout()} and
* {@link View#invalidate()} on this parent.
*
* @param child The child to bring to the top of the z order
*/
public void bringChildToFront(View child);
/**
* Tells the parent that a new focusable view has become available. This is
* to handle transitions from the case where there are no focusable views to
* the case where the first focusable view appears.
*
* @param v The view that has become newly focusable
*/
public void focusableViewAvailable(View v);
/**
* Bring up a context menu for the specified view or its ancestors.
*
* <p>In most cases, a subclass does not need to override this. However, if
* the subclass is added directly to the window manager (for example,
* {@link ViewManager#addView(View, android.view.ViewGroup.LayoutParams)})
* then it should override this and show the context menu.</p>
*
* @param originalView The source view where the context menu was first invoked
* @return true if a context menu was displayed
*/
public boolean showContextMenuForChild(View originalView);
/**
* Have the parent populate the specified context menu if it has anything to
* add (and then recurse on its parent).
*
* @param menu The menu to populate
*/
public void createContextMenu(ContextMenu menu);
/**
* Start an action mode for the specified view.
*
* <p>In most cases, a subclass does not need to override this. However, if the
* subclass is added directly to the window manager (for example,
* {@link ViewManager#addView(View, android.view.ViewGroup.LayoutParams)})
* then it should override this and start the action mode.</p>
*
* @param originalView The source view where the action mode was first invoked
* @param callback The callback that will handle lifecycle events for the action mode
* @return The new action mode if it was started, null otherwise
*/
public ActionMode startActionModeForChild(View originalView, ActionMode.Callback callback);
/**
* This method is called on the parent when a child's drawable state
* has changed.
*
* @param child The child whose drawable state has changed.
*/
public void childDrawableStateChanged(View child);
/**
* Called when a child does not want this parent and its ancestors to
* intercept touch events with
* {@link ViewGroup#onInterceptTouchEvent(MotionEvent)}.
*
* <p>This parent should pass this call onto its parents. This parent must obey
* this request for the duration of the touch (that is, only clear the flag
* after this parent has received an up or a cancel.</p>
*
* @param disallowIntercept True if the child does not want the parent to
* intercept touch events.
*/
public void requestDisallowInterceptTouchEvent(boolean disallowIntercept);
/**
* Called when a child of this group wants a particular rectangle to be
* positioned onto the screen. {@link ViewGroup}s overriding this can trust
* that:
* <ul>
* <li>child will be a direct child of this group</li>
* <li>rectangle will be in the child's coordinates</li>
* </ul>
*
* <p>{@link ViewGroup}s overriding this should uphold the contract:</p>
* <ul>
* <li>nothing will change if the rectangle is already visible</li>
* <li>the view port will be scrolled only just enough to make the
* rectangle visible</li>
* <ul>
*
* @param child The direct child making the request.
* @param rectangle The rectangle in the child's coordinates the child
* wishes to be on the screen.
* @param immediate True to forbid animated or delayed scrolling,
* false otherwise
* @return Whether the group scrolled to handle the operation
*/
public boolean requestChildRectangleOnScreen(View child, Rect rectangle,
boolean immediate);
/**
* Called by a child to request from its parent to send an {@link AccessibilityEvent}.
* The child has already populated a record for itself in the event and is delegating
* to its parent to send the event. The parent can optionally add a record for itself.
* <p>
* Note: An accessibility event is fired by an individual view which populates the
* event with a record for its state and requests from its parent to perform
* the sending. The parent can optionally add a record for itself before
* dispatching the request to its parent. A parent can also choose not to
* respect the request for sending the event. The accessibility event is sent
* by the topmost view in the view tree.</p>
*
* @param child The child which requests sending the event.
* @param event The event to be sent.
* @return True if the event was sent.
*/
public boolean requestSendAccessibilityEvent(View child, AccessibilityEvent event);
/**
* Called when a child view now has or no longer is tracking transient state.
*
* @param child Child view whose state has changed
* @param hasTransientState true if this child has transient state
*
* @hide
*/
public void childHasTransientStateChanged(View child, boolean hasTransientState);
/**
* Ask that a new dispatch of {@link View#fitSystemWindows(Rect)
* View.fitSystemWindows(Rect)} be performed.
*/
public void requestFitSystemWindows();
/**
* Gets the parent of a given View for accessibility. Since some Views are not
* exposed to the accessibility layer the parent for accessibility is not
* necessarily the direct parent of the View, rather it is a predecessor.
*
* @return The parent or <code>null</code> if no such is found.
*/
public ViewParent getParentForAccessibility();
/**
* A child notifies its parent that its state for accessibility has changed.
* That is some of the child properties reported to accessibility services has
* changed, hence the interested services have to be notified for the new state.
*
* @hide
*/
public void childAccessibilityStateChanged(View child);
/**
* Tells if this view parent can resolve the layout direction.
* See {@link View#setLayoutDirection(int)}
*
* @return True if this view parent can resolve the layout direction.
*
* @hide
*/
public boolean canResolveLayoutDirection();
/**
* Tells if this view parent layout direction is resolved.
* See {@link View#setLayoutDirection(int)}
*
* @return True if this view parent layout direction is resolved.
*
* @hide
*/
public boolean isLayoutDirectionResolved();
/**
* Return this view parent layout direction. See {@link View#getLayoutDirection()}
*
* @return {@link View#LAYOUT_DIRECTION_RTL} if the layout direction is RTL or returns
* {@link View#LAYOUT_DIRECTION_LTR} if the layout direction is not RTL.
*
* @hide
*/
public int getLayoutDirection();
/**
* Tells if this view parent can resolve the text direction.
* See {@link View#setTextDirection(int)}
*
* @return True if this view parent can resolve the text direction.
*
* @hide
*/
public boolean canResolveTextDirection();
/**
* Tells if this view parent text direction is resolved.
* See {@link View#setTextDirection(int)}
*
* @return True if this view parent text direction is resolved.
*
* @hide
*/
public boolean isTextDirectionResolved();
/**
* Return this view parent text direction. See {@link View#getTextDirection()}
*
* @return the resolved text direction. Returns one of:
*
* {@link View#TEXT_DIRECTION_FIRST_STRONG}
* {@link View#TEXT_DIRECTION_ANY_RTL},
* {@link View#TEXT_DIRECTION_LTR},
* {@link View#TEXT_DIRECTION_RTL},
* {@link View#TEXT_DIRECTION_LOCALE}
*
* @hide
*/
public int getTextDirection();
/**
* Tells if this view parent can resolve the text alignment.
* See {@link View#setTextAlignment(int)}
*
* @return True if this view parent can resolve the text alignment.
*
* @hide
*/
public boolean canResolveTextAlignment();
/**
* Tells if this view parent text alignment is resolved.
* See {@link View#setTextAlignment(int)}
*
* @return True if this view parent text alignment is resolved.
*
* @hide
*/
public boolean isTextAlignmentResolved();
/**
* Return this view parent text alignment. See {@link android.view.View#getTextAlignment()}
*
* @return the resolved text alignment. Returns one of:
*
* {@link View#TEXT_ALIGNMENT_GRAVITY},
* {@link View#TEXT_ALIGNMENT_CENTER},
* {@link View#TEXT_ALIGNMENT_TEXT_START},
* {@link View#TEXT_ALIGNMENT_TEXT_END},
* {@link View#TEXT_ALIGNMENT_VIEW_START},
* {@link View#TEXT_ALIGNMENT_VIEW_END}
*
* @hide
*/
public int getTextAlignment();可以看到addView, updateViewLayout, removeView, requestLayout, bringChildToFront等等重要的方法都在这两个接口里面得到定义,下面来一一分析一下：
一、addView(View view, ViewGroup.LayoutParams params)方法的实现：
/**
* Adds a child view with the specified layout parameters.
*
* <p><strong>Note:</strong> do not invoke this method from
* {@link #draw(android.graphics.Canvas)}, {@link #onDraw(android.graphics.Canvas)},
* {@link #dispatchDraw(android.graphics.Canvas)} or any related method.</p>
*
* @param child the child view to add
* @param params the layout parameters to set on the child
*/
public void addView(View child, LayoutParams params) {
addView(child, -1, params);
}
/**
* Adds a child view with the specified layout parameters.
*
* <p><strong>Note:</strong> do not invoke this method from
* {@link #draw(android.graphics.Canvas)}, {@link #onDraw(android.graphics.Canvas)},
* {@link #dispatchDraw(android.graphics.Canvas)} or any related method.</p>
*
* @param child the child view to add
* @param index the position at which to add the child
* @param params the layout parameters to set on the child
*/
public void addView(View child, int index, LayoutParams params) {
if (DBG) {
System.out.println(this + " addView");
}
// addViewInner() will call child.requestLayout() when setting the new LayoutParams
// therefore, we call requestLayout() on ourselves before, so that the child's request
// will be blocked at our level
requestLayout();
invalidate(true);
addViewInner(child, index, params, false);
}
private void addViewInner(View child, int index, LayoutParams params,
boolean preventRequestLayout) {
if (child.getParent() != null) {
throw new IllegalStateException("The specified child already has a parent. " +
"You must call removeView() on the child's parent first.");
}
if (!checkLayoutParams(params)) {
params = generateLayoutParams(params);
}
if (preventRequestLayout) {
child.mLayoutParams = params;
} else {
child.setLayoutParams(params);
}
if (index < 0) {
index = mChildrenCount;
}
addInArray(child, index);
// tell our children
if (preventRequestLayout) {
child.assignParent(this);
} else {
child.mParent = this;
}
if (child.hasFocus()) {
requestChildFocus(child, child.findFocus());
}
AttachInfo ai = mAttachInfo;
if (ai != null) {
boolean lastKeepOn = ai.mKeepScreenOn;
ai.mKeepScreenOn = false;
child.dispatchAttachedToWindow(mAttachInfo, (mViewFlags&VISIBILITY_MASK));
if (ai.mKeepScreenOn) {
needGlobalAttributesUpdate(true);
}
ai.mKeepScreenOn = lastKeepOn;
}
if (mOnHierarchyChangeListener != null) {
mOnHierarchyChangeListener.onChildViewAdded(this, child);
}
if ((child.mViewFlags & DUPLICATE_PARENT_STATE) == DUPLICATE_PARENT_STATE) {
mGroupFlags |= FLAG_NOTIFY_CHILDREN_ON_DRAWABLE_STATE_CHANGE;
}
}这里可以看到我们写代码的时候经常看到的一个异常，也解释了index的具体含义。我们也可以看到：每一个View都保存了一个指向父View的指针。倒数第二段代码，也用到一个接口，可以监听子View的添加和删除：
/**
* Interface definition for a callback to be invoked when the hierarchy
* within this view changed. The hierarchy changes whenever a child is added
* to or removed from this view.
*/
public interface OnHierarchyChangeListener {
/**
* Called when a new child is added to a parent view.
*
* @param parent the view in which a child was added
* @param child the new child view added in the hierarchy
*/
void onChildViewAdded(View parent, View child);
/**
* Called when a child is removed from a parent view.
*
* @param parent the view from which the child was removed
* @param child the child removed from the hierarchy
*/
void onChildViewRemoved(View parent, View child);
}二、removeView
removeView方法除了正常调用requestLayout和invalidate方法以外：
/**
* Removes the specified range of views from the group.
*
* @param start the first position in the group of the range of views to remove
* @param count the number of views to remove
*/
public void removeViews(int start, int count) {
removeViewsInternal(start, count);
requestLayout();
invalidate();
}但是看下面两个方法：
/**
* {@inheritDoc}
*/
public void removeView(View view) {
removeViewInternal(view);
requestLayout();
invalidate();
}
/**
* Removes a view during layout. This is useful if in your onLayout() method,
* you need to remove more views.
*
* @param view the view to remove from the group
*/
public void removeViewInLayout(View view) {
removeViewInternal(view);
}后者没有调用requestLayout和invalidate，但是后者的说明里面提到是在onLayout()方法中调用这个方法的。所以如果没有猜错的话，在布局完成后调用后面一个方法对界面是没有影响的，好的转入正题：
private void removeViewInternal(int index, View view) {
boolean clearChildFocus = false;
if (view == mFocused) {
view.clearFocusForRemoval();
clearChildFocus = true;
}
if (view.getAnimation() != null) {
addDisappearingView(view);
} else if (view.mAttachInfo != null) {
view.dispatchDetachedFromWindow();
}
if (mOnHierarchyChangeListener != null) {
mOnHierarchyChangeListener.onChildViewRemoved(this, view);
}
needGlobalAttributesUpdate(false);
removeFromArray(index);
if (clearChildFocus) {
clearChildFocus(view);
}
}这里的删除貌似只是从Array中删除了一个元素（更加印证了前面提到的说法）。只有调用onLayout和onMeasure方法之后才会诱发界面重新布局。
三、测量函数
/**
* Ask all of the children of this view to measure themselves, taking into
* account both the MeasureSpec requirements for this view and its padding.
* We skip children that are in the GONE state The heavy lifting is done in
* getChildMeasureSpec.
*
* @param widthMeasureSpec The width requirements for this view
* @param heightMeasureSpec The height requirements for this view
*/
protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
final int size = mChildrenCount;
final View[] children = mChildren;
for (int i = 0; i < size; ++i) {
final View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
measureChild(child, widthMeasureSpec, heightMeasureSpec);
}
}
}
/**
* Ask one of the children of this view to measure itself, taking into
* account both the MeasureSpec requirements for this view and its padding.
* The heavy lifting is done in getChildMeasureSpec.
*
* @param child The child to measure
* @param parentWidthMeasureSpec The width requirements for this view
* @param parentHeightMeasureSpec The height requirements for this view
*/
protected void measureChild(View child, int parentWidthMeasureSpec,
int parentHeightMeasureSpec) {
final LayoutParams lp = child.getLayoutParams();
final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
mPaddingLeft + mPaddingRight, lp.width);
final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
mPaddingTop + mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}前者只不过是告诉这个Group把自己所有的View全部测量一下，后者则是测量单个子View的大小。这边无疑涉及到一个方法：
/**
* Does the hard part of measureChildren: figuring out the MeasureSpec to
* pass to a particular child. This method figures out the right MeasureSpec
* for one dimension (height or width) of one child view.
*
* The goal is to combine information from our MeasureSpec with the
* LayoutParams of the child to get the best possible results. For example,
* if the this view knows its size (because its MeasureSpec has a mode of
* EXACTLY), and the child has indicated in its LayoutParams that it wants
* to be the same size as the parent, the parent should ask the child to
* layout given an exact size.
*
* @param spec The requirements for this view
* @param padding The padding of this view for the current dimension and
* margins, if applicable
* @param childDimension How big the child wants to be in the current
* dimension
* @return a MeasureSpec integer for the child
*/
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
int specMode = MeasureSpec.getMode(spec);
int specSize = MeasureSpec.getSize(spec);
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 = 0;
resultMode = MeasureSpec.UNSPECIFIED;
} else if (childDimension == LayoutParams.WRAP_CONTENT) {
// Child wants to determine its own size.... find out how
// big it should be
resultSize = 0;
resultMode = MeasureSpec.UNSPECIFIED;
}
break;
}
return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}三种模式的判断，进行不同的赋值！这些值会传递给子View，告诉它们父View的大小。
四、布局参数LayoutParams
/**
* LayoutParams are used by views to tell their parents how they want to be
* laid out. See
* {@link android.R.styleable#ViewGroup_Layout ViewGroup Layout Attributes}
* for a list of all child view attributes that this class supports.
*
* <p>
* The base LayoutParams class just describes how big the view wants to be
* for both width and height. For each dimension, it can specify one of:
* <ul>
* <li>FILL_PARENT (renamed MATCH_PARENT in API Level 8 and higher), which
* means that the view wants to be as big as its parent (minus padding)
* <li> WRAP_CONTENT, which means that the view wants to be just big enough
* to enclose its content (plus padding)
* <li> an exact number
* </ul>
* There are subclasses of LayoutParams for different subclasses of
* ViewGroup. For example, AbsoluteLayout has its own subclass of
* LayoutParams which adds an X and Y value.
*
* @attr ref android.R.styleable#ViewGroup_Layout_layout_height
* @attr ref android.R.styleable#ViewGroup_Layout_layout_width
*/
public static class LayoutParams {
/**
* Special value for the height or width requested by a View.
* FILL_PARENT means that the view wants to be as big as its parent,
* minus the parent's padding, if any. This value is deprecated
* starting in API Level 8 and replaced by {@link #MATCH_PARENT}.
*/
@SuppressWarnings({"UnusedDeclaration"})
@Deprecated
public static final int FILL_PARENT = -1;
/**
* Special value for the height or width requested by a View.
* MATCH_PARENT means that the view wants to be as big as its parent,
* minus the parent's padding, if any. Introduced in API Level 8.
*/
public static final int MATCH_PARENT = -1;
/**
* Special value for the height or width requested by a View.
* WRAP_CONTENT means that the view wants to be just large enough to fit
* its own internal content, taking its own padding into account.
*/
public static final int WRAP_CONTENT = -2;
/**
* Information about how wide the view wants to be. Can be one of the
* constants FILL_PARENT (replaced by MATCH_PARENT ,
* in API Level 8) or WRAP_CONTENT. or an exact size.
*/
@ViewDebug.ExportedProperty(mapping = {
@ViewDebug.IntToString(from = MATCH_PARENT, to = "MATCH_PARENT"),
@ViewDebug.IntToString(from = WRAP_CONTENT, to = "WRAP_CONTENT")
})
public int width;
/**
* Information about how tall the view wants to be. Can be one of the
* constants FILL_PARENT (replaced by MATCH_PARENT ,
* in API Level 8) or WRAP_CONTENT. or an exact size.
*/
@ViewDebug.ExportedProperty(mapping = {
@ViewDebug.IntToString(from = MATCH_PARENT, to = "MATCH_PARENT"),
@ViewDebug.IntToString(from = WRAP_CONTENT, to = "WRAP_CONTENT")
})
public int height;
/**
* Used to animate layouts.
*/
public LayoutAnimationController.AnimationParameters layoutAnimationParameters;
/**
* Creates a new set of layout parameters. The values are extracted from
* the supplied attributes set and context. The XML attributes mapped
* to this set of layout parameters are:
*
* <ul>
* <li><code>layout_width</code>: the width, either an exact value,
* {@link #WRAP_CONTENT}, or {@link #FILL_PARENT} (replaced by
* {@link #MATCH_PARENT} in API Level 8)</li>
* <li><code>layout_height</code>: the height, either an exact value,
* {@link #WRAP_CONTENT}, or {@link #FILL_PARENT} (replaced by
* {@link #MATCH_PARENT} in API Level 8)</li>
* </ul>
*
* @param c the application environment
* @param attrs the set of attributes from which to extract the layout
* parameters' values
*/
public LayoutParams(Context c, AttributeSet attrs) {
TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.ViewGroup_Layout);
setBaseAttributes(a,
R.styleable.ViewGroup_Layout_layout_width,
R.styleable.ViewGroup_Layout_layout_height);
a.recycle();
}
/**
* Creates a new set of layout parameters with the specified width
* and height.
*
* @param width the width, either {@link #WRAP_CONTENT},
* {@link #FILL_PARENT} (replaced by {@link #MATCH_PARENT} in
* API Level 8), or a fixed size in pixels
* @param height the height, either {@link #WRAP_CONTENT},
* {@link #FILL_PARENT} (replaced by {@link #MATCH_PARENT} in
* API Level 8), or a fixed size in pixels
*/
public LayoutParams(int width, int height) {
this.width = width;
this.height = height;
}
/**
* Copy constructor. Clones the width and height values of the source.
*
* @param source The layout params to copy from.
*/
public LayoutParams(LayoutParams source) {
this.width = source.width;
this.height = source.height;
}
/**
* Used internally by MarginLayoutParams.
* @hide
*/
LayoutParams() {
}
/**
* Extracts the layout parameters from the supplied attributes.
*
* @param a the style attributes to extract the parameters from
* @param widthAttr the identifier of the width attribute
* @param heightAttr the identifier of the height attribute
*/
protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
width = a.getLayoutDimension(widthAttr, "layout_width");
height = a.getLayoutDimension(heightAttr, "layout_height");
}
/**
* Returns a String representation of this set of layout parameters.
*
* @param output the String to prepend to the internal representation
* @return a String with the following format: output +
* "ViewGroup.LayoutParams={ width=WIDTH, height=HEIGHT }"
*
* @hide
*/
public String debug(String output) {
return output + "ViewGroup.LayoutParams={ width="
+ sizeToString(width) + ", height=" + sizeToString(height) + " }";
}
/**
* Converts the specified size to a readable String.
*
* @param size the size to convert
* @return a String instance representing the supplied size
*
* @hide
*/
protected static String sizeToString(int size) {
if (size == WRAP_CONTENT) {
return "wrap-content";
}
if (size == MATCH_PARENT) {
return "match-parent";
}
return String.valueOf(size);
}
}
4794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
