ViewParent

bringChildToFront

void bringChildToFront (View child)

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). Prior to KITKAT this method should be followed by calls to requestLayout() and invalidate() on this parent to force the parent to redraw with the new child ordering.

canResolveLayoutDirection

boolean canResolveLayoutDirection ()

Tells if this view parent can resolve the layout direction. See setLayoutDirection(int)

canResolveTextAlignment

boolean canResolveTextAlignment ()

Tells if this view parent can resolve the text alignment. See setTextAlignment(int)

canResolveTextDirection

boolean canResolveTextDirection ()

Tells if this view parent can resolve the text direction. See setTextDirection(int)

childDrawableStateChanged

void childDrawableStateChanged (View child)

This method is called on the parent when a child's drawable state has changed.

childHasTransientStateChanged

void childHasTransientStateChanged (View child, 
                boolean hasTransientState)

Called when a child view now has or no longer is tracking transient state.

"Transient state" is any state that a View might hold that is not expected to be reflected in the data model that the View currently presents. This state only affects the presentation to the user within the View itself, such as the current state of animations in progress or the state of a text selection operation.

Transient state is useful for hinting to other components of the View system that a particular view is tracking something complex but encapsulated. A ListView for example may acknowledge that list item Views with transient state should be preserved within their position or stable item ID instead of treating that view as trivially replaceable by the backing adapter. This allows adapter implementations to be simpler instead of needing to track the state of item view animations in progress such that they could be restored in the event of an unexpected recycling and rebinding of attached item views.

This method is called on a parent view when a child view or a view within its subtree begins or ends tracking of internal transient state.

clearChildFocus

void clearChildFocus (View child)

Called when a child of this parent is giving up focus

createContextMenu

void createContextMenu (ContextMenu menu)

Have the parent populate the specified context menu if it has anything to add (and then recurse on its parent).

focusSearch

View focusSearch (View v, 
                int direction)

Find the nearest view in the specified direction that wants to take focus

focusableViewAvailable

void focusableViewAvailable (View v)

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.

getChildVisibleRect

boolean getChildVisibleRect (View child, 
                Rect r, 
                Point offset)

Compute the visible part of a rectangular region defined in terms of a child view's coordinates.

Returns the clipped visible part of the rectangle r, defined in the child's local coordinate system. r is modified by this method to contain the result, expressed in the global (root) coordinate system.

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.

getLayoutDirection

int getLayoutDirection ()

Return this view parent layout direction. See getLayoutDirection()

getParent

ViewParent getParent ()

Returns the parent if it exists, or null.

getParentForAccessibility

ViewParent getParentForAccessibility ()

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.

getTextAlignment

int getTextAlignment ()

Return this view parent text alignment. See getTextAlignment()

getTextDirection

int getTextDirection ()

Return this view parent text direction. See getTextDirection()

invalidateChild

void invalidateChild (View child, 
                Rect r)

All or part of a child is dirty and needs to be redrawn.

invalidateChildInParent

ViewParent invalidateChildInParent (int[] location, 
                Rect r)

All or part of a child is dirty and needs to be redrawn.

The location array is an array of two int values which respectively define the left and the top position of the dirty child.

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.

When this method returns a non-null value, the location array must have been updated with the left and top coordinates of this ViewParent.

isLayoutDirectionResolved

boolean isLayoutDirectionResolved ()

Tells if this view parent layout direction is resolved. See setLayoutDirection(int)

isLayoutRequested

boolean isLayoutRequested ()

Indicates whether layout was requested on this view parent.

isTextAlignmentResolved

boolean isTextAlignmentResolved ()

Tells if this view parent text alignment is resolved. See setTextAlignment(int)

isTextDirectionResolved

boolean isTextDirectionResolved ()

Tells if this view parent text direction is resolved. See setTextDirection(int)

notifySubtreeAccessibilityStateChanged

void notifySubtreeAccessibilityStateChanged (View child, 
                View source, 
                int changeType)

Notifies a view parent that the accessibility state of one of its descendants has changed and that the structure of the subtree is different.

onNestedFling

boolean onNestedFling (View target, 
                float velocityX, 
                float velocityY, 
                boolean consumed)

Request a fling from a nested scroll.

This method signifies that a nested scrolling child has detected suitable conditions for a fling. Generally this means that a touch scroll has ended with a velocity in the direction of scrolling that meets or exceeds the minimum fling velocity along a scrollable axis.

If a nested scrolling child view would normally fling but it is at the edge of its own content, it can use this method to delegate the fling to its nested scrolling parent instead. The parent may optionally consume the fling or observe a child fling.

onNestedPreFling

boolean onNestedPreFling (View target, 
                float velocityX, 
                float velocityY)

React to a nested fling before the target view consumes it.

This method siginfies that a nested scrolling child has detected a fling with the given velocity along each axis. Generally this means that a touch scroll has ended with a velocity in the direction of scrolling that meets or exceeds the minimum fling velocity along a scrollable axis.

If a nested scrolling parent is consuming motion as part of a pre-scroll, it may be appropriate for it to also consume the pre-fling to complete that same motion. By returning true from this method, the parent indicates that the child should not fling its own internal content as well.

onNestedPrePerformAccessibilityAction

boolean onNestedPrePerformAccessibilityAction (View target, 
                int action, 
                Bundle arguments)

React to an accessibility action delegated by a target descendant view before the target processes it.

This method may be called by a target descendant view if the target wishes to give a view in its parent chain a chance to react to the event before normal processing occurs. Most commonly this will be a scroll event such as ACTION_SCROLL_FORWARD. A ViewParent that supports acting as a nested scrolling parent should override this method and act accordingly to implement scrolling via accesibility systems.

onNestedPreScroll

void onNestedPreScroll (View target, 
                int dx, 
                int dy, 
                int[] consumed)

React to a nested scroll in progress before the target view consumes a portion of the scroll.

When working with nested scrolling often the parent view may want an opportunity to consume the scroll before the nested scrolling child does. An example of this is a drawer that contains a scrollable list. The user will want to be able to scroll the list fully into view before the list itself begins scrolling.

onNestedPreScroll is called when a nested scrolling child invokes dispatchNestedPreScroll(int, int, int[], int[]). The implementation should report how any pixels of the scroll reported by dx, dy were consumed in the consumed array. Index 0 corresponds to dx and index 1 corresponds to dy. This parameter will never be null. Initial values for consumed[0] and consumed[1] will always be 0.

onNestedScroll

void onNestedScroll (View target, 
                int dxConsumed, 
                int dyConsumed, 
                int dxUnconsumed, 
                int dyUnconsumed)

React to a nested scroll in progress.

This method will be called when the ViewParent's current nested scrolling child view dispatches a nested scroll event. To receive calls to this method the ViewParent must have previously returned true for a call to onStartNestedScroll(View, View, int).

Both the consumed and unconsumed portions of the scroll distance are reported to the ViewParent. An implementation may choose to use the consumed portion to match or chase scroll position of multiple child elements, for example. The unconsumed portion may be used to allow continuous dragging of multiple scrolling or draggable elements, such as scrolling a list within a vertical drawer where the drawer begins dragging once the edge of inner scrolling content is reached.

onNestedScrollAccepted

void onNestedScrollAccepted (View child, 
                View target, 
                int nestedScrollAxes)

React to the successful claiming of a nested scroll operation.

This method will be called after onStartNestedScroll returns true. It offers an opportunity for the view and its superclasses to perform initial configuration for the nested scroll. Implementations of this method should always call their superclass's implementation of this method if one is present.

onStartNestedScroll

boolean onStartNestedScroll (View child, 
                View target, 
                int nestedScrollAxes)

React to a descendant view initiating a nestable scroll operation, claiming the nested scroll operation if appropriate.

This method will be called in response to a descendant view invoking startNestedScroll(int). Each parent up the view hierarchy will be given an opportunity to respond and claim the nested scrolling operation by returning true.

This method may be overridden by ViewParent implementations to indicate when the view is willing to support a nested scrolling operation that is about to begin. If it returns true, this ViewParent will become the target view's nested scrolling parent for the duration of the scroll operation in progress. When the nested scroll is finished this ViewParent will receive a call to onStopNestedScroll(View).

onStopNestedScroll

void onStopNestedScroll (View target)

React to a nested scroll operation ending.

Perform cleanup after a nested scrolling operation. This method will be called when a nested scroll stops, for example when a nested touch scroll ends with a ACTION_UP or ACTION_CANCEL event. Implementations of this method should always call their superclass's implementation of this method if one is present.

recomputeViewAttributes

void recomputeViewAttributes (View child)

Tell view hierarchy that the global view attributes need to be re-evaluated.

requestChildFocus

void requestChildFocus (View child, 
                View focused)

Called when a child of this parent wants focus

requestChildRectangleOnScreen

boolean requestChildRectangleOnScreen (View child, 
                Rect rectangle, 
                boolean immediate)

Called when a child of this group wants a particular rectangle to be positioned onto the screen. ViewGroups overriding this can trust that:

• child will be a direct child of this group
• rectangle will be in the child's content coordinates

ViewGroups overriding this should uphold the contract:

• nothing will change if the rectangle is already visible
• the view port will be scrolled only just enough to make the rectangle visible

Parameters
child	View: The direct child making the request.
rectangle	Rect: The rectangle in the child's coordinates the child wishes to be on the screen.
immediate	boolean: True to forbid animated or delayed scrolling, false otherwise

Returns
boolean	Whether the group scrolled to handle the operation

requestDisallowInterceptTouchEvent

void requestDisallowInterceptTouchEvent (boolean disallowIntercept)

Called when a child does not want this parent and its ancestors to intercept touch events with onInterceptTouchEvent(MotionEvent).

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.

requestFitSystemWindows

void requestFitSystemWindows ()

Ask that a new dispatch of View.fitSystemWindows(Rect) be performed.

requestLayout

void requestLayout ()

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.

requestSendAccessibilityEvent

boolean requestSendAccessibilityEvent (View child, 
                AccessibilityEvent event)

Called by a child to request from its parent to send an 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.

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.

requestTransparentRegion

void requestTransparentRegion (View child)

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.

showContextMenuForChild

boolean showContextMenuForChild (View originalView)

Shows the context menu for the specified view or its ancestors.

In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, addView(View, android.view.ViewGroup.LayoutParams)) then it should override this and show the context menu.

showContextMenuForChild

boolean showContextMenuForChild (View originalView, 
                float x, 
                float y)

Shows the context menu for the specified view or its ancestors anchored to the specified view-relative coordinate.

In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, addView(View, android.view.ViewGroup.LayoutParams)) then it should override this and show the context menu.

If a subclass overrides this method it should also override showContextMenuForChild(View).

startActionModeForChild

ActionMode startActionModeForChild (View originalView, 
                ActionMode.Callback callback, 
                int type)

Start an action mode of a specific type for the specified view.

In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, addView(View, android.view.ViewGroup.LayoutParams)) then it should override this and start the action mode.

startActionModeForChild

ActionMode startActionModeForChild (View originalView, 
                ActionMode.Callback callback)

Start an action mode for the specified view with the default type TYPE_PRIMARY.

In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, addView(View, android.view.ViewGroup.LayoutParams)) then it should override this and start the action mode.