HorizontalScrollView

Layout container for a view hierarchy that can be scrolled by the user,
allowing it to be larger than the physical display. A HorizontalScrollView
is a FrameLayout, meaning you should place one child in it
containing the entire contents to scroll; this child may itself be a layout
manager with a complex hierarchy of objects. A child that is often used
is a LinearLayout in a horizontal orientation, presenting a horizontal
array of top-level items that the user can scroll through.

The TextView class also
takes care of its own scrolling, so does not require a HorizontalScrollView, but
using the two together is possible to achieve the effect of a text view
within a larger container.

HorizontalScrollView only supports horizontal scrolling. For vertical scrolling,
use either ScrollView or ListView.

Defines the next view to give focus to when the next focus is
View.FOCUS_DOWN
If the reference refers to a view that does not exist or is part
of a hierarchy that is invisible, a RuntimeException
will result when the reference is accessed.

Defines the next view to give focus to when the next focus is
View.FOCUS_FORWARD
If the reference refers to a view that does not exist or is part
of a hierarchy that is invisible, a RuntimeException
will result when the reference is accessed.

Defines the next view to give focus to when the next focus is
View.FOCUS_RIGHT
If the reference refers to a view that does not exist or is part
of a hierarchy that is invisible, a RuntimeException
will result when the reference is accessed.

Defines the next view to give focus to when the next focus is
View.FOCUS_UP
If the reference refers to a view that does not exist or is part
of a hierarchy that is invisible, a RuntimeException
will result when the reference is accessed.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Autofill type for a field that contains a date, which is represented by a long representing
the number of milliseconds since the standard base time known as "the epoch", namely
January 1, 1970, 00:00:00 GMT (see Date.getTime().

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This constant was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Flag for setSystemUiVisibility(int): View has requested to go
into the normal fullscreen mode so that its content can take over the screen
while still allowing the user to interact with the application.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Indicates whether the view is currently tracking transient state that the
app should not need to concern itself with saving and restoring, but that
the framework should take special note to preserve when possible.

Call this to try to give focus to a specific view or to one of its descendants
and give it hints about the direction and a specific rectangle that the focus
is coming from.
Looks for a view to give focus to respecting the setting specified by
getDescendantFocusability().

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, View.setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call View.draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method tells the ViewGroup that the given View object, which should have this
ViewGroup as its parent,
should be kept around (re-displayed when the ViewGroup draws its children) even if it
is removed from its parent.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Indicates whether the view is currently tracking transient state that the
app should not need to concern itself with saving and restoring, but that
the framework should take special note to preserve when possible.

This method was deprecated
in API level 28.
The switch to hardware accelerated rendering in API 14 reduced
the importance of the dirty rectangle. In API 21 the given rectangle is
ignored entirely in favor of an internally-calculated area instead.
Because of this, clients are encouraged to just call invalidate().

This method was deprecated
in API level 28.
The switch to hardware accelerated rendering in API 14 reduced
the importance of the dirty rectangle. In API 21 the given rectangle is
ignored entirely in favor of an internally-calculated area instead.
Because of this, clients are encouraged to just call invalidate().

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Sets whether or not this view should account for system screen decorations
such as the status bar and inset its content; that is, controlling whether
the default implementation of fitSystemWindows(Rect) will be
executed.

When screen readers (one type of accessibility tool) decide what should be read to the
user, they typically look for input focusable (isFocusable()) parents of
non-focusable text items, and read those focusable parents and their non-focusable children
as a unit.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

This method was deprecated
in API level 28.
The view drawing cache was largely made obsolete with the introduction of
hardware-accelerated rendering in API 11. With hardware-acceleration, intermediate cache
layers are largely unnecessary and can easily result in a net loss in performance due to the
cost of creating and updating the layer. In the rare cases where caching layers are useful,
such as for alpha animations, setLayerType(int, Paint) handles this with hardware
rendering. For software-rendered snapshots of a small part of the View hierarchy or
individual Views it is recommended to create a Canvas from either a Bitmap or
Picture and call draw(Canvas) on the View. However these
software-rendered usages are discouraged and have compatibility issues with hardware-only
rendering features such as Config.HARDWARE
bitmaps, real-time shadows, and outline clipping. For screenshots of the UI for feedback
reports or unit testing the PixelCopy API is recommended.

Causes the current thread to wait until another thread invokes the
notify() method or the
notifyAll() method for this object, or
some other thread interrupts the current thread, or a certain
amount of real time has elapsed.

dispatchKeyEvent

Dispatch a key event to the next view on the focus path. This path runs
from the top of the view tree down to the currently focused view. If this
view has focus, it will dispatch to itself. Otherwise it will dispatch
the next node down the focus path. This method also fires any key
listeners.

Parameters

event

KeyEvent: The key event to be dispatched.

Returns

boolean

True if the event was handled, false otherwise.

draw

Manually render this view (and all of its children) to the given Canvas.
The view must have already done a full layout before this function is
called. When implementing a view, implement
onDraw(android.graphics.Canvas) instead of overriding this method.
If you do need to override this method, call the superclass version.

fullScroll

Handles scrolling in response to a "home/end" shortcut press. This
method will scroll the view to the left or right and give the focus
to the leftmost/rightmost component in the new visible area. If no
component is a good candidate for focus, this scrollview reclaims the
focus.

getAccessibilityClassName

Return the class name of this object to be used for accessibility purposes.
Subclasses should only override this if they are implementing something that
should be seen as a completely new class of view when used by accessibility,
unrelated to the class it is deriving from. This is used to fill in
AccessibilityNodeInfo.setClassName.

onGenericMotionEvent

Generic motion events describe joystick movements, mouse hovers, track pad
touches, scroll wheel movements and other input events. The
source of the motion event specifies
the class of input that was received. Implementations of this method
must examine the bits in the source before processing the event.
The following code example shows how this is done.

Generic motion events with source class InputDevice.SOURCE_CLASS_POINTER
are delivered to the view under the pointer. All other generic motion events are
delivered to the focused view.

onInterceptTouchEvent

Implement this method to intercept all touch screen motion events. This
allows you to watch events as they are dispatched to your children, and
take ownership of the current gesture at any point.

Using this function takes some care, as it has a fairly complicated
interaction with View.onTouchEvent(MotionEvent), and using it requires implementing
that method as well as this one in the correct way. Events will be
received in the following order:

You will receive the down event here.

The down event will be handled either by a child of this view
group, or given to your own onTouchEvent() method to handle; this means
you should implement onTouchEvent() to return true, so you will
continue to see the rest of the gesture (instead of looking for
a parent view to handle it). Also, by returning true from
onTouchEvent(), you will not receive any following
events in onInterceptTouchEvent() and all touch processing must
happen in onTouchEvent() like normal.

For as long as you return false from this function, each following
event (up to and including the final up) will be delivered first here
and then to the target's onTouchEvent().

If you return true from here, you will not receive any
following events: the target view will receive the same event but
with the action MotionEvent.ACTION_CANCEL, and all further
events will be delivered to your onTouchEvent() method and no longer
appear here.

Parameters

ev

MotionEvent: The motion event being dispatched down the hierarchy.

Returns

boolean

Return true to steal motion events from the children and have
them dispatched to this ViewGroup through onTouchEvent().
The current target will receive an ACTION_CANCEL event, and no further
messages will be delivered here.

pageScroll

Handles scrolling in response to a "page up/down" shortcut press. This
method will scroll the view by one page left or right and give the focus
to the leftmost/rightmost component in the new visible area. If no
component is a good candidate for focus, this scrollview reclaims the
focus.

requestLayout

Call this when something has changed which has invalidated the
layout of this view. This will schedule a layout pass of the view
tree. This should not be called while the view hierarchy is currently in a layout
pass (isInLayout(). If layout is happening, the request may be honored at the
end of the current layout pass (and then layout will run again) or after the current
frame is drawn and the next layout occurs.

Subclasses which override this method should call the superclass method to
handle possible request-during-layout errors correctly.

setOverScrollMode

Set the over-scroll mode for this view. Valid over-scroll modes are
OVER_SCROLL_ALWAYS (default), OVER_SCROLL_IF_CONTENT_SCROLLS
(allow over-scrolling only if the view content is larger than the container),
or OVER_SCROLL_NEVER.
Setting the over-scroll mode of a view will have an effect only if the
view is capable of scrolling.

shouldDelayChildPressedState

Return true if the pressed state should be delayed for children or descendants of this
ViewGroup. Generally, this should be done for containers that can scroll, such as a List.
This prevents the pressed state from appearing when the user is actually trying to scroll
the content.
The default implementation returns true for compatibility reasons. Subclasses that do
not scroll should generally override this method and return false.

getLeftFadingEdgeStrength

Returns the strength, or intensity, of the left faded edge. The strength is
a value between 0.0 (no fade) and 1.0 (full fade). The default implementation
returns 0.0 or 1.0 but no value in between.
Subclasses should override this method to provide a smoother fade transition
when scrolling occurs.

Returns

float

the intensity of the left fade as a float between 0.0f and 1.0f

getRightFadingEdgeStrength

Returns the strength, or intensity, of the right faded edge. The strength is
a value between 0.0 (no fade) and 1.0 (full fade). The default implementation
returns 0.0 or 1.0 but no value in between.
Subclasses should override this method to provide a smoother fade transition
when scrolling occurs.

measureChildWithMargins

Ask one of the children of this view to measure itself, taking into
account both the MeasureSpec requirements for this view and its padding
and margins. The child must have MarginLayoutParams The heavy lifting is
done in getChildMeasureSpec.

Parameters

child

View: The child to measure

parentWidthMeasureSpec

int: The width requirements for this view

widthUsed

int: Extra space that has been used up by the parent
horizontally (possibly by other children of the parent)

parentHeightMeasureSpec

int: The height requirements for this view

heightUsed

int: Extra space that has been used up by the parent
vertically (possibly by other children of the parent)

onMeasure

Measure the view and its content to determine the measured width and the
measured height. This method is invoked by measure(int, int) and
should be overridden by subclasses to provide accurate and efficient
measurement of their contents.

The base class implementation of measure defaults to the background size,
unless a larger size is allowed by the MeasureSpec. Subclasses should
override onMeasure(int, int) to provide better measurements of
their content.

onRequestFocusInDescendants

When looking for focus in children of a scroll view, need to be a little
more careful not to give focus to something that is scrolled off screen.
This is more expensive than the default ViewGroup
implementation, otherwise this behavior might have been made the default.

Parameters

direction

int: One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT

previouslyFocusedRect

Rect: The rectangle (in this View's coordinate system)
to give a finer grained hint about where focus is coming from. May be null
if there is no hint.

onSaveInstanceState

Hook allowing a view to generate a representation of its internal state
that can later be used to create a new instance with that same state.
This state should only contain information that is not persistent or can
not be reconstructed later. For example, you will never store your
current position on screen because that will be computed again when a
new instance of the view is placed in its view hierarchy.

Some examples of things you may store here: the current cursor position
in a text view (but usually not the text itself since that is stored in a
content provider or other persistent storage), the currently selected
item in a list view.