KeyboardView

Adds the children of this View relevant for accessibility to the given list as output. Since some Views are not important for accessibility the added child views are not necessarily direct children of this view, rather they are the first level of descendants important for accessibility.

Adds extra data to an AccessibilityNodeInfo based on an explicit request for the additional data.

This method only needs overloading if the node is marked as having extra data available.

Add any focusable views that are descendants of this view (possibly including this view if it is focusable itself) to views. If we are in touch mode, only add views that are also focusable in touch mode.

Adds any focusable views that are descendants of this view (possibly including this view if it is focusable itself) to views. This method adds all focusable views regardless if we are in touch mode or only views focusable in touch mode if we are in touch mode or only views that can take accessibility focus if accessibility is enabled depending on the focusable mode parameter.

Adds any keyboard navigation cluster roots that are descendants of this view (possibly including this view if it is a cluster root itself) to views.

Add a listener for attach state changes. This listener will be called whenever this view is attached or detached from a window. Remove the listener using removeOnAttachStateChangeListener(android.view.View.OnAttachStateChangeListener).

Add a listener that will be called when the bounds of the view change due to layout processing.

Adds a listener which will receive unhandled KeyEvents. This must be called on the UI thread.

Add any touchable views that are descendants of this view (possibly including this view if it is touchable itself) to views.

This method returns a ViewPropertyAnimator object, which can be used to animate specific properties on this View.

Convenience method for sending a AccessibilityEvent.TYPE_ANNOUNCEMENT AccessibilityEvent to suggest that an accessibility service announce the specified text to its users.

Note: The event generated with this API carries no semantic meaning, and accessibility services may choose to ignore it. Apps that accurately supply accessibility with the semantics of their UI should not need to specify what exactly is announced.

In general, do not attempt to generate announcements as confirmation message for simple actions like a button press. Label your controls concisely and precisely instead.

To convey significant UI changes like window changes, use android.app.Activity#setTitle(CharSequence) and setAccessibilityPaneTitle(java.lang.CharSequence).

Use setAccessibilityLiveRegion(int) to inform the user of changes to critical views within the user interface. These should still be used sparingly as they may generate announcements every time a View is updated.

Use setStateDescription(java.lang.CharSequence) to convey state changes to views within the user interface. While a live region may send different types of events generated by the view, state description will send AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED events of type AccessibilityEvent.CONTENT_CHANGE_TYPE_STATE_DESCRIPTION.

For notifying users about errors, such as in a login screen with text that displays an "incorrect password" notification, set AccessibilityNodeInfo.setError(CharSequence) and dispatch an AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED event with a change type of AccessibilityEvent.CONTENT_CHANGE_TYPE_ERROR, instead. Some widgets may expose methods that convey error states to accessibility automatically, such as android.widget.TextView#setError(CharSequence), which manages these accessibility semantics and event dispatch for callers.

Automatically fills the content of the virtual children within this view.

Views with virtual children support the Autofill Framework mainly by:

• Providing the metadata defining what the virtual children mean and how they can be autofilled.
• Implementing the methods that autofill the virtual children.

onProvideAutofillVirtualStructure(android.view.ViewStructure,int) is responsible for the former, this method is responsible for the latter - see autofill(android.view.autofill.AutofillValue) and onProvideAutofillVirtualStructure(android.view.ViewStructure,int) for more info about autofill.

If a child value is updated asynchronously, the next call to AutofillManager.notifyValueChanged(View, int, AutofillValue) must happen after the value was changed to the autofilled value. If not, the child will not be considered autofilled.

Note: To indicate that a virtual view was autofilled, ?android:attr/autofilledHighlight should be drawn over it until the data changes.

Automatically fills the content of this view with the value.

Views support the Autofill Framework mainly by:

• Providing the metadata defining what the view means and how it can be autofilled.
• Implementing the methods that autofill the view.

onProvideAutofillStructure(android.view.ViewStructure,int) is responsible for the former, this method is responsible for latter.

This method does nothing by default, but when overridden it typically:

1. Checks if the provided value matches the expected type (which is defined by getAutofillType()).
2. Checks if the view is editable - if it isn't, it should return right away.
3. Call the proper getter method on AutofillValue to fetch the actual value.
4. Pass the actual value to the equivalent setter in the view.

For example, a text-field view could implement the method this way:

@Override
  public void autofill(AutofillValue value) {
    if (!value.isText() || !this.isEditable()) {
       return;
    }
    CharSequence text = value.getTextValue();
    if (text != null) {
      this.setText(text);
    }
  }
  

If the value is updated asynchronously, the next call to AutofillManager.notifyValueChanged(View) must happen after the value was changed to the autofilled value. If not, the view will not be considered autofilled.

Note: After this method is called, the value returned by getAutofillValue() must be equal to the value passed to it, otherwise the view will not be highlighted as autofilled.

Trigger the scrollbars to draw. When invoked this method starts an animation to fade the scrollbars out after a default delay. If a subclass provides animated scrolling, the start delay should equal the duration of the scrolling animation.

The animation starts only if at least one of the scrollbars is enabled, as specified by isHorizontalScrollBarEnabled() and isVerticalScrollBarEnabled(). When the animation is started, this method returns true, and false otherwise. If the animation is started, this method calls invalidate(); in that case the caller should not call invalidate().

This method should be invoked every time a subclass directly updates the scroll parameters.

This method is automatically invoked by scrollBy(int,int) and scrollTo(int,int).

Trigger the scrollbars to draw. When invoked this method starts an animation to fade the scrollbars out after a fixed delay. If a subclass provides animated scrolling, the start delay should equal the duration of the scrolling animation.

The animation starts only if at least one of the scrollbars is enabled, as specified by isHorizontalScrollBarEnabled() and isVerticalScrollBarEnabled(). When the animation is started, this method returns true, and false otherwise. If the animation is started, this method calls invalidate(); in that case the caller should not call invalidate().

This method should be invoked every time a subclass directly updates the scroll parameters.

Trigger the scrollbars to draw. When invoked this method starts an animation to fade the scrollbars out after a fixed delay. If a subclass provides animated scrolling, the start delay should equal the duration of the scrolling animation.

The animation starts only if at least one of the scrollbars is enabled, as specified by isHorizontalScrollBarEnabled() and isVerticalScrollBarEnabled(). When the animation is started, this method returns true, and false otherwise. If the animation is started, this method calls invalidate() if the invalidate parameter is set to true; in that case the caller should not call invalidate().

This method should be invoked every time a subclass directly updates the scroll parameters.

Change the view's z order in the tree, so it's on top of other sibling views. This ordering change may affect layout, if the parent container uses an order-dependent layout scheme (e.g., LinearLayout). Prior to android.os.Build.VERSION_CODES#KITKAT this method should be followed by calls to requestLayout() and View.invalidate() on the view's parent to force the parent to redraw with the new child ordering.

Calling this method is equivalent to calling buildDrawingCache(false).

Forces the drawing cache to be built if the drawing cache is invalid.

If you call buildDrawingCache() manually without calling setDrawingCacheEnabled(true), you should cleanup the cache by calling destroyDrawingCache() afterwards.

Note about auto scaling in compatibility mode: When auto scaling is not enabled, this method will create a bitmap of the same size as this view. Because this bitmap will be drawn scaled by the parent ViewGroup, the result on screen might show scaling artifacts. To avoid such artifacts, you should call this method by setting the auto scaling to true. Doing so, however, will generate a bitmap of a different size than the view. This implies that your application must be able to handle this size.

You should avoid calling this method when hardware acceleration is enabled. If you do not need the drawing cache bitmap, calling this method will increase memory usage and cause the view to be rendered in software once, thus negatively impacting performance.

Forces this view's layer to be created and this view to be rendered into its layer. If this view's layer type is set to LAYER_TYPE_NONE, invoking this method will have no effect. This method can for instance be used to render a view into its layer before starting an animation. If this view is complex, rendering into the layer before starting the animation will avoid skipping frames.

Directly call any attached OnClickListener. Unlike performClick(), this only calls the listener, and does not do any associated clicking actions like reporting an accessibility event.

Check if layout direction resolution can be done.

Check if text alignment resolution can be done.

Check if text direction resolution can be done.

Check if this view can be scrolled horizontally in a certain direction.

This is without regard to whether the view is enabled or not, or if it will scroll in response to user input or not.

Check if this view can be scrolled vertically in a certain direction.

This is without regard to whether the view is enabled or not, or if it will scroll in response to user input or not.

Cancels an ongoing drag and drop operation.

A android.view.DragEvent object with android.view.DragEvent#getAction() value of android.view.DragEvent#ACTION_DRAG_ENDED and android.view.DragEvent#getResult() value of false will be sent to every View that received android.view.DragEvent#ACTION_DRAG_STARTED even if they are not currently visible.

This method can be called on any View in the same window as the View on which startDragAndDrop was called.

Cancels a pending long press. Your subclass can use this if you want the context menu to come up if the user presses and holds at the same place, but you don't want it to come up if they press and then move around enough to cause scrolling.

Cancel any deferred high-level input events that were previously posted to the event queue.

Many views post high-level events such as click handlers to the event queue to run deferred in order to preserve a desired user experience - clearing visible pressed states before executing, etc. This method will abort any events of this nature that are currently in flight.

Custom views that generate their own high-level deferred input events should override onCancelPendingInputEvents() and remove those pending events from the queue.

This will also cancel pending input events for any child views.

Note that this may not be sufficient as a debouncing strategy for clicks in all cases. This will not impact newer events posted after this call that may occur as a result of lower-level input events still waiting in the queue. If you are trying to prevent double-submitted events for the duration of some sort of asynchronous transaction you should also take other steps to protect against unexpected double inputs e.g. calling setEnabled(false) and re-enabling the view when the transaction completes, tracking already submitted transaction IDs, etc.

Called by the android.view.inputmethod.InputMethodManager when a view who is not the current input connection target is trying to make a call on the manager. The default implementation returns false; you can override this to return true for certain views if you are performing InputConnection proxying to them.

Cancels any animations for this view.

Called when this view wants to give up focus. If focus is cleared onFocusChanged(boolean,int,android.graphics.Rect) is called.

Note: When not in touch-mode, the framework will try to give focus to the first focusable View from the top after focus is cleared. Hence, if this View is the first from the top that can take focus, then all callbacks related to clearing focus will be invoked after which the framework will give focus to this view.

Clears the request and callback previously set through View.setPendingCredentialRequest. Once this API is invoked, there will be no request fired to CredentialManager on future view focus events.

Clear the ViewTranslationCallback from this view.

Merge two states as returned by getMeasuredState().

Compute the horizontal extent of the horizontal scrollbar's thumb within the horizontal range. This value is used to compute the length of the thumb within the scrollbar's track.

The range is expressed in arbitrary units that must be the same as the units used by computeHorizontalScrollRange() and computeHorizontalScrollOffset().

The default extent is the drawing width of this view.

Compute the horizontal offset of the horizontal scrollbar's thumb within the horizontal range. This value is used to compute the position of the thumb within the scrollbar's track.

The range is expressed in arbitrary units that must be the same as the units used by computeHorizontalScrollRange() and computeHorizontalScrollExtent().

The default offset is the scroll offset of this view.

Compute the horizontal range that the horizontal scrollbar represents.

The range is expressed in arbitrary units that must be the same as the units used by computeHorizontalScrollExtent() and computeHorizontalScrollOffset().

The default range is the drawing width of this view.

Called by a parent to request that a child update its values for mScrollX and mScrollY if necessary. This will typically be done if the child is animating a scroll using a Scroller object.

Compute insets that should be consumed by this view and the ones that should propagate to those under it.

Compute the vertical extent of the vertical scrollbar's thumb within the vertical range. This value is used to compute the length of the thumb within the scrollbar's track.

The range is expressed in arbitrary units that must be the same as the units used by computeVerticalScrollRange() and computeVerticalScrollOffset().

The default extent is the drawing height of this view.

Compute the vertical offset of the vertical scrollbar's thumb within the horizontal range. This value is used to compute the position of the thumb within the scrollbar's track.

The range is expressed in arbitrary units that must be the same as the units used by computeVerticalScrollRange() and computeVerticalScrollExtent().

The default offset is the scroll offset of this view.

Compute the vertical range that the vertical scrollbar represents.

The range is expressed in arbitrary units that must be the same as the units used by computeVerticalScrollExtent() and computeVerticalScrollOffset().

Returns an AccessibilityNodeInfo representing this view from the point of view of an android.accessibilityservice.AccessibilityService. This method is responsible for obtaining an accessibility node info from a pool of reusable instances and calling onInitializeAccessibilityNodeInfo(android.view.accessibility.AccessibilityNodeInfo) on this view to initialize the former.

Note: The client is responsible for recycling the obtained instance by calling AccessibilityNodeInfo.recycle() to minimize object creation.

Show the context menu for this view. It is not safe to hold on to the menu after returning from this method. You should normally not overload this method. Overload onCreateContextMenu(android.view.ContextMenu) or define an OnCreateContextMenuListener to add items to the context menu.

Frees the resources used by the drawing cache. If you call buildDrawingCache() manually without calling setDrawingCacheEnabled(true), you should cleanup the cache with this method afterwards.

Request to apply the given window insets to this view or another view in its subtree.

This method should be called by clients wishing to apply insets corresponding to areas obscured by window decorations or overlays. This can include the status and navigation bars, action bars, input methods and more. New inset categories may be added in the future. The method returns the insets provided minus any that were applied by this view or its children.

Clients wishing to provide custom behavior should override the onApplyWindowInsets(android.view.WindowInsets) method or alternatively provide a OnApplyWindowInsetsListener via the setOnApplyWindowInsetsListener method.

This method replaces the older fitSystemWindows method.

Pass a captured pointer event down to the focused view.

Dispatch a notification about a resource configuration change down the view hierarchy. ViewGroups should override to route to their children.

Dispatch to collect the ViewTranslationRequests for translation purpose by traversing the hierarchy when the app requests ui translation. Typically, this method should only be overridden by subclasses that provide a view hierarchy (such as ViewGroup). Other classes should override View.onCreateViewTranslationRequest for normal view or override View.onVirtualViewTranslationResponses for view contains virtual children. When requested to start the ui translation, the system will call this method to traverse the view hierarchy to collect ViewTranslationRequests and create a android.view.translation.Translator to translate the requests. All the ViewTranslationRequests must be added when the traversal is done.

The default implementation calls View.onCreateViewTranslationRequest for normal view or calls View.onVirtualViewTranslationResponses for view contains virtual children to build ViewTranslationRequest if the view should be translated. The view is marked as having transient state so that recycling of views doesn't prevent the system from attaching the response to it. Therefore, if overriding this method, you should set or reset the transient state.

Dispatch a hint about whether this view is displayed. For instance, when a View moves out of the screen, it might receives a display hint indicating the view is not displayed. Applications should not rely on this hint as there is no guarantee that they will receive one.

Detects if this View is enabled and has a drag event listener. If both are true, then it calls the drag event listener with the android.view.DragEvent it received. If the drag event listener returns true, then dispatchDragEvent() returns true.

For all other cases, the method calls the onDragEvent() drag event handler method and returns its result.

This ensures that a drag event is always consumed, even if the View does not have a drag event listener. However, if the View has a listener and the listener returns true, then onDragEvent() is not called.

Called by draw to draw the child views. This may be overridden by derived classes to gain control just before its children are drawn (but after its own view has been drawn).

Dispatches drawableHotspotChanged to all of this View's children.

Dispatch onFinishTemporaryDetach() to this View and its direct children if this is a container View.
If you override this method you must call through to the superclass implementation.

Dispatch a generic motion event to the currently focused view.

Do not call this method directly. Call dispatchGenericMotionEvent(android.view.MotionEvent) instead.

Dispatch a generic motion event.

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. Hover events are handled specially and are delivered to onHoverEvent(android.view.MotionEvent) first.

Dispatch a generic motion event to the view under the first pointer.

Do not call this method directly. Call dispatchGenericMotionEvent(android.view.MotionEvent) instead.

Dispatch a hover event.

Do not call this method directly. Call dispatchGenericMotionEvent(android.view.MotionEvent) instead.

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.

Dispatch a key event before it is processed by any input method associated with the view hierarchy. This can be used to intercept key events in special situations before the IME consumes them; a typical example would be handling the BACK key to update the application's UI instead of allowing the IME to see it and close itself.

Dispatches a key shortcut event.

Dispatch a fling to a nested scrolling parent.

This method should be used to indicate 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.

Dispatch a fling to a nested scrolling parent before it is processed by this view.

Nested pre-fling events are to nested fling events what touch intercept is to touch and what nested pre-scroll is to nested scroll. dispatchNestedPreFling offsets an opportunity for the parent view in a nested fling to fully consume the fling before the child view consumes it. If this method returns true, a nested parent view consumed the fling and this view should not scroll as a result.

For a better user experience, only one view in a nested scrolling chain should consume the fling at a time. If a parent view consumed the fling this method will return false. Custom view implementations should account for this in two ways:

• If a custom view is paged and needs to settle to a fixed page-point, do not call dispatchNestedPreFling; consume the fling and settle to a valid position regardless.
• If a nested parent does consume the fling, this view should not scroll at all, even to settle back to a valid idle position.

Views should also not offer fling velocities to nested parent views along an axis where scrolling is not currently supported; a ScrollView should not offer a horizontal fling velocity to its parents since scrolling along that axis is not permitted and carrying velocity along that motion does not make sense.

Report an accessibility action to this view's parents for delegated processing.

Implementations of performAccessibilityAction(int,android.os.Bundle) may internally call this method to delegate an accessibility action to a supporting parent. If the parent returns true from its ViewParent.onNestedPrePerformAccessibilityAction(View, int, android.os.Bundle) method this method will return true to signify that the action was consumed.

This method is useful for implementing nested scrolling child views. If isNestedScrollingEnabled() returns true and the action is a scrolling action a custom view implementation may invoke this method to allow a parent to consume the scroll first. If this method returns true the custom view should skip its own scrolling behavior.

Dispatch one step of a nested scroll in progress before this view consumes any portion of it.

Nested pre-scroll events are to nested scroll events what touch intercept is to touch. dispatchNestedPreScroll offers an opportunity for the parent view in a nested scrolling operation to consume some or all of the scroll operation before the child view consumes it.

Dispatch one step of a nested scroll in progress.

Implementations of views that support nested scrolling should call this to report info about a scroll in progress to the current nested scrolling parent. If a nested scroll is not currently in progress or nested scrolling is not enabled for this view this method does nothing.

Compatible View implementations should also call dispatchNestedPreScroll before consuming a component of the scroll event themselves.

Dispatches an AccessibilityEvent to the View to add the text content of the view and its children.

Note: This method should only be used with event.setText(). Avoid mutating other event state in this method. In general, put UI metadata in the node for services to easily query.

• If you are modifying other event properties, you may be eliminating semantics accessibility services may want. Instead, send a separate event using sendAccessibilityEvent(int) and override onInitializeAccessibilityEvent(android.view.accessibility.AccessibilityEvent).
• If you are checking for type AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED to generate window/title announcements, you may be causing disruptive announcements (or making no announcements at all). Instead, follow the practices described in View.announceForAccessibility(CharSequence). Note: this does not suggest calling announceForAccessibility(), but using the suggestions listed in its documentation.
• If you are making changes based on the state of accessibility, such as checking for an event type to trigger a UI update, while well-intentioned, you are creating brittle, less well-maintained code that works for some users but not others. Instead, leverage existing code for equitable experiences and less technical debt. See AccessibilityManager.isEnabled() for an example.

Note that the event text is populated in a separate dispatch path (onPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent)) since we add to the event not only the text of the source but also the text of all its descendants.

A typical implementation will call onPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent) on this view and then call the dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent) on each child or the first child that is visible. Override this method if custom population of the event text content is required.

If an AccessibilityDelegate has been specified via calling setAccessibilityDelegate(android.view.View.AccessibilityDelegate) its AccessibilityDelegate.dispatchPopulateAccessibilityEvent(View, AccessibilityEvent) is responsible for handling this call.

If this view sets isAccessibilityDataSensitive() then this view should only append sensitive information to an event that also sets AccessibilityEvent.isAccessibilityDataSensitive().

Note: Accessibility events of certain types are not dispatched for populating the event text via this method. For details refer to AccessibilityEvent.

Dispatches creation of a ViewStructures for autofill purposes down the hierarchy, when an Assist structure is being created as part of an autofill request.

The default implementation does the following:

• Sets the AutofillId in the structure.
• Calls onProvideAutofillStructure(android.view.ViewStructure,int).
• Calls onProvideAutofillVirtualStructure(android.view.ViewStructure,int).

Typically, this method should only be overridden by subclasses that provide a view hierarchy (such as ViewGroup) - other classes should override onProvideAutofillStructure(android.view.ViewStructure,int) or onProvideAutofillVirtualStructure(android.view.ViewStructure,int) instead.

When overridden, it must:

• Either call super.dispatchProvideAutofillStructure(structure, flags) or explicitly set the AutofillId in the structure (for example, by calling structure.setAutofillId(getAutofillId())).
• Decide how to handle the AUTOFILL_FLAG_INCLUDE_NOT_IMPORTANT_VIEWS flag - when set, all views in the structure should be considered important for autofill, regardless of what isImportantForAutofill() returns. We encourage you to respect this flag to provide a better user experience - this flag is typically used when an user explicitly requested autofill. If the flag is not set, then only views marked as important for autofill should be included in the structure - skipping non-important views optimizes the overall autofill performance.

Dispatch creation of ViewStructure down the hierarchy. The default implementation calls onProvideStructure and onProvideVirtualStructure.

Called by restoreHierarchyState(android.util.SparseArray) to retrieve the state for this view and its children. May be overridden to modify how restoring happens to a view's children; for example, some views may want to not store state for their children.

Called by saveHierarchyState(android.util.SparseArray) to store the state for this view and its children. May be overridden to modify how freezing happens to a view's children; for example, some views may want to not store state for their children.

Dispatch a scroll capture search request down the view hierarchy.

Dispatch setActivated to all of this View's children.

Dispatch setPressed to all of this View's children.

Dispatch setSelected to all of this View's children.

Dispatch onStartTemporaryDetach() to this View and its direct children if this is a container View.
If you override this method you must call through to the superclass implementation.

Dispatch callbacks to setOnSystemUiVisibilityChangeListener down the view hierarchy.

Pass the touch screen motion event down to the target view, or this view if it is the target.

Pass a trackball motion event down to the focused view.

This method is the last chance for the focused view and its ancestors to respond to an arrow key. This is called when the focused view did not consume the key internally, nor could the view system find a new view in the requested direction to give focus to.

Dispatch a view visibility change down the view hierarchy. ViewGroups should override to route to their children.

Called when the window containing this view gains or loses window focus. ViewGroups should override to route to their children.

Dispatches WindowInsetsAnimation.Callback.onEnd(WindowInsetsAnimation) when Window Insets animation ends.

Dispatches WindowInsetsAnimation.Callback.onPrepare(WindowInsetsAnimation) when Window Insets animation is being prepared.

Dispatches WindowInsetsAnimation.Callback.onProgress(WindowInsets, List) when Window Insets animation makes progress.

Dispatches WindowInsetsAnimation.Callback.onStart(WindowInsetsAnimation, Bounds) when Window Insets animation is started.

Dispatch callbacks to onWindowSystemUiVisibilityChanged(int) down the view hierarchy.

Dispatch a window visibility change down the view hierarchy. ViewGroups should override to route to their children.

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.
If you override this method you must call through to the superclass implementation.

This function is called whenever the view hotspot changes and needs to be propagated to drawables or child views managed by the view.

Dispatching to child views is handled by dispatchDrawableHotspotChanged(float,float).

Be sure to call through to the superclass when overriding this function.
If you override this method you must call through to the superclass implementation.

This function is called whenever the state of the view changes in such a way that it impacts the state of drawables being shown.

If the View has a StateListAnimator, it will also be called to run necessary state change animations.

Be sure to call through to the superclass when overriding this function.
If you override this method you must call through to the superclass implementation.

Find the view in the hierarchy rooted at this view that currently has focus.

Walk up the View hierarchy to find the nearest OnBackInvokedDispatcher.

Finds the first descendant view with the given ID, the view itself if the ID matches getId(), or null if the ID is invalid (< 0) or there is no matching view in the hierarchy.

Note: In most cases -- depending on compiler support -- the resulting view is automatically cast to the target class type. If the target class type is unconstrained, an explicit cast may be necessary.

Look for a child view with the given tag. If this view has the given tag, return this view.

Finds the Views that contain given text. The containment is case insensitive. The search is performed by either the text that the View renders or the content description that describes the view for accessibility purposes and the view does not render or both. Clients can specify how the search is to be performed via passing the FIND_VIEWS_WITH_TEXT and FIND_VIEWS_WITH_CONTENT_DESCRIPTION flags.

Called by the view hierarchy when the content insets for a window have changed, to allow it to adjust its content to fit within those windows. The content insets tell you the space that the status bar, input method, and other system windows infringe on the application's window.

You do not normally need to deal with this function, since the default window decoration given to applications takes care of applying it to the content of the window. If you use SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION this will not be the case, and your content can be placed under those system elements. You can then use this method within your view hierarchy if you have parts of your UI which you would like to ensure are not being covered.

The default implementation of this method simply applies the content insets to the view's padding, consuming that content (modifying the insets to be 0), and returning true. This behavior is off by default, but can be enabled through setFitsSystemWindows(boolean).

This function's traversal down the hierarchy is depth-first. The same content insets object is propagated down the hierarchy, so any changes made to it will be seen by all following views (including potentially ones above in the hierarchy since this is a depth-first traversal). The first view that returns true will abort the entire traversal.

The default implementation works well for a situation where it is used with a container that covers the entire window, allowing it to apply the appropriate insets to its content on all edges. If you need a more complicated layout (such as two different views fitting system windows, one on the top of the window, and one on the bottom), you can override the method and handle the insets however you would like. Note that the insets provided by the framework are always relative to the far edges of the window, not accounting for the location of the called view within that window. (In fact when this method is called you do not yet know where the layout will place the view, as it is done before layout happens.)

Note: unlike many View methods, there is no dispatch phase to this call. If you are overriding it in a ViewGroup and want to allow the call to continue to your children, you must be sure to call the super implementation.

Here is a sample layout that makes use of fitting system windows to have controls for a video view placed inside of the window decorations that it hides and shows. This can be used with code like the second sample (video player) shown in setSystemUiVisibility(int).

Find the nearest view in the specified direction that can take focus. This does not actually give focus to that view.

Sets the behavior for overlapping rendering for this view (see hasOverlappingRendering() for more details on this behavior). Calling this method is an alternative to overriding hasOverlappingRendering() in a subclass, providing the value which is then used internally. That is, when forceHasOverlappingRendering(boolean) is called, the value of hasOverlappingRendering() is ignored and the value passed into this method is used instead.

Forces this view to be laid out during the next layout pass. This method does not call requestLayout() or forceLayout() on the parent.

This is used by the ViewRoot to perform an optimization when the view hierarchy contains one or several SurfaceView. SurfaceView is always considered transparent, but its children are not, therefore all View objects remove themselves from the global transparent region (passed as a parameter to this function).

Called to generate a DisplayHash for this view.

Generate a value suitable for use in setId(int). This value will not collide with ID values generated at build time by aapt for R.id.

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.

Returns the delegate for implementing accessibility support via composition. For more details see AccessibilityDelegate.

Gets the live region mode for this View.

Gets the provider for managing a virtual view hierarchy rooted at this View and reported to android.accessibilityservice.AccessibilityServices that explore the window content.

If this method returns an instance, this instance is responsible for managing AccessibilityNodeInfos describing the virtual sub-tree rooted at this View including the one representing the View itself. Similarly the returned instance is responsible for performing accessibility actions on any virtual view or the root view itself.

If an AccessibilityDelegate has been specified via calling setAccessibilityDelegate(android.view.View.AccessibilityDelegate) its AccessibilityDelegate.getAccessibilityNodeProvider(View) is responsible for handling this call.

Get the title of the pane for purposes of accessibility.

Gets the id of a view after which this one is visited in accessibility traversal.

Gets the id of a view before which this one is visited in accessibility traversal.

Returns the allowed package for delegate editor views for which this view may act as a handwriting delegator, as set by setAllowedHandwritingDelegatePackage. If setAllowedHandwritingDelegatePackage has not been called, or called with null argument, this will return null, meaning that this delegator view may only be used to initiate handwriting mode for a delegate editor view from the same package as this delegator view.

Returns the allowed package for views which may act as a handwriting delegator for this delegate editor view, as set by setAllowedHandwritingDelegatorPackage. If setAllowedHandwritingDelegatorPackage has not been called, or called with null argument, this will return null, meaning that only views from the same package as this delegator editor view may act as a handwriting delegator.

The opacity of the view. This is a value from 0 to 1, where 0 means the view is completely transparent and 1 means the view is completely opaque.

By default this is 1.0f.

Get the animation currently associated with this view.

Return the current transformation matrix of the view. This is used in animation frameworks, such as android.transition.Transition. Returns null when there is no transformation provided by setAnimationMatrix(android.graphics.Matrix). Application developers should use transformation methods like setRotation(float), setScaleX(float), setScaleX(float), setTranslationX(float)} and setTranslationY(float) (float)}} instead.

Retrieve a unique token identifying the top-level "real" window of the window that this view is attached to. That is, this is like getWindowToken, except if the window this view in is a panel window (attached to another containing window), then the token of the containing window is returned instead.

Returns the ordered list of resource ID that are considered when resolving attribute values for this View. The list will include layout resource ID if the View is inflated from XML. It will also include a set of explicit styles if specified in XML using style="...". Finally, it will include the default styles resolved from the theme.

Note: this method will only return actual values if the view attribute debugging is enabled in Android developer options.

Returns the mapping of attribute resource ID to source resource ID where the attribute value was set. Source resource ID can either be a layout resource ID, if the value was set in XML within the View tag, or a style resource ID, if the attribute was set in a style. The source resource value will be one of the resource IDs from getAttributeSourceResourceMap().

Note: this method will only return actual values if the view attribute debugging is enabled in Android developer options.

Gets the hints that help an android.service.autofill.AutofillService determine how to autofill the view with the user's data.

See setAutofillHints(java.lang.String...) for more info about these hints.

Gets the unique, logical identifier of this view in the activity, for autofill purposes.

The autofill id is created on demand, unless it is explicitly set by setAutofillId(android.view.autofill.AutofillId).

See setAutofillId(android.view.autofill.AutofillId) for more info.

Describes the autofill type of this view, so an android.service.autofill.AutofillService can create the proper AutofillValue when autofilling the view.

By default returns AUTOFILL_TYPE_NONE, but views should override it to properly support the Autofill Framework.

Gets the View's current autofill value.

By default returns null, but subclasses should override it and return an appropriate value to properly support the Autofill Framework.

Gets the background drawable

Return the blending mode used to apply the tint to the background drawable, if specified.

Return the tint applied to the background drawable, if specified.

Return the blending mode used to apply the tint to the background drawable, if specified.

Return the offset of the widget's text baseline from the widget's top boundary. If this widget does not support baseline alignment, this method returns -1.

Bottom position of this view relative to its parent.

Returns the strength, or intensity, of the bottom 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.

Amount by which to extend the bottom fading region. Called only when isPaddingOffsetRequired() returns true.

Gets the distance along the Z axis from the camera to this view.

Returns a copy of the current clipBounds.

Populates an output rectangle with the clip bounds of the view, returning true if successful or false if the view's clip bounds are null.

Returns whether the Outline should be used to clip the contents of the View.

Note that this flag will only be respected if the View's Outline returns true from Outline.canClip().

Gets the session used to notify content capture events.

Returns the View's content description.

Note: Do not override this method, as it will have no effect on the content description presented to accessibility services. You must call setContentDescription(java.lang.CharSequence) to modify the content description.

Gets content sensitivity mode to determine whether this view displays sensitive content.

See setContentSensitivity(int) and isContentSensitive() for more info about this mode.

Returns the context the view is running in, through which it can access the current theme, resources, etc.

Views should implement this if they have extra information to associate with the context menu. The return result is supplied as a parameter to the OnCreateContextMenuListener.onCreateContextMenu(ContextMenu, View, ContextMenuInfo) callback.

Returns whether this View should use a default focus highlight when it gets focused but doesn't have android.R.attr#state_focused defined in its background.

Utility to return a default size. Uses the supplied size if the MeasureSpec imposed no constraints. Will get larger if allowed by the MeasureSpec.

Gets the logical display to which the view's window has been attached.

Return an array of resource IDs of the drawable states representing the current state of the view.

Calling this method is equivalent to calling getDrawingCache(false).

Returns the bitmap in which this view drawing is cached. The returned bitmap is null when caching is disabled. If caching is enabled and the cache is not ready, this method will create it. Calling draw(android.graphics.Canvas) will not draw from the cache when the cache is enabled. To benefit from the cache, you must request the drawing cache by calling this method and draw it on screen if the returned bitmap is not null.

Note about auto scaling in compatibility mode: When auto scaling is not enabled, this method will create a bitmap of the same size as this view. Because this bitmap will be drawn scaled by the parent ViewGroup, the result on screen might show scaling artifacts. To avoid such artifacts, you should call this method by setting the auto scaling to true. Doing so, however, will generate a bitmap of a different size than the view. This implies that your application must be able to handle this size.

Returns the quality of the drawing cache.

Return the visible drawing bounds of your view. Fills in the output rectangle with the values from getScrollX(), getScrollY(), getWidth(), and getHeight(). These bounds do not account for any transformation properties currently set on the view, such as setScaleX(float) or setRotation(float).

Return the time at which the drawing of the view hierarchy started.

The base elevation of this view relative to its parent, in pixels.

Returns the resource ID for the style specified using style="..." in the AttributeSet's backing XML element or Resources.ID_NULL otherwise if not specified or otherwise not applicable.

Each View can have an explicit style specified in the layout file. This style is used first during the View attribute resolution, then if an attribute is not defined there the resource system looks at default style and theme as fallbacks.

Note: this method will only return actual values if the view attribute debugging is enabled in Android developer options.

Gets whether the framework should discard touches when the view's window is obscured by another visible window at the touched location. Refer to the View security documentation for more details.

Check for state of setFitsSystemWindows(boolean). If this method returns true, the default implementation of fitSystemWindows(android.graphics.Rect) will be executed.

Returns the focusable setting for this view.

Find and return all focusable views that are descendants of this view, possibly including this view if it is focusable itself.

When a view has focus and the user navigates away from it, the next view is searched for starting from the rectangle filled in by this method. By default, the rectangle is the getDrawingRect(android.graphics.Rect)) of the view. However, if your view maintains some idea of internal selection, such as a cursor, or a selected row or column, you should override this method and fill in a more specific rectangle.

Returns the drawable used as the foreground of this View. The foreground drawable, if non-null, is always drawn on top of the view's content.

Describes how the foreground is positioned.

Return the blending mode used to apply the tint to the foreground drawable, if specified.

Return the tint applied to the foreground drawable, if specified.

Return the blending mode used to apply the tint to the foreground drawable, if specified.

Get the current velocity of the View. The value should always be greater than or equal to 0. Note that this is only valid till the next drawn frame.

Sets r to the coordinates of the non-clipped area of this view in the coordinate space of the view's root view.

See getGlobalVisibleRect(Rect, Point) for more information.

Sets r to the coordinates of the non-clipped area of this view in the coordinate space of the view's root view. Sets globalOffset to the offset of the view's x and y coordinates from the coordinate space origin, which is the top left corner of the root view irrespective of screen decorations and system UI elements.

To convert r to coordinates relative to the top left corner of this view (without taking view rotations into account), offset r by the inverse values of globalOffset—r.offset(-globalOffset.x, -globalOffset.y)—which is equivalent to calling getLocalVisibleRect(Rect).

Note: Do not use this method to determine the size of a window in multi-window mode; use WindowManager.getCurrentWindowMetrics().

Return the amount of offset applied to the bottom edge of this view's handwriting bounds, in the unit of pixel.

Return the amount of offset applied to the left edge of this view's handwriting bounds, in the unit of pixel.

Return the amount of offset applied to the right edge of this view's handwriting bounds, in the unit of pixel.

Return the amount of offset applied to the top edge of this view's handwriting bounds, in the unit of pixel.

Returns flags configuring the handwriting delegation behavior for this delegate editor view, as set by setHandwritingDelegateFlags.

Returns the callback set by setHandwritingDelegatorCallback which should be called when a stylus MotionEvent occurs within this view's bounds. The callback should only be called from the UI thread.

Returns the value for overlapping rendering that is used internally. This is either the value passed into forceHasOverlappingRendering(boolean), if called, or the return value of hasOverlappingRendering(), otherwise.

Return the height of your view.

Hit rectangle in parent's coordinates

Returns the size of the horizontal faded edges used to indicate that more content in this view is visible.

Returns the height of the horizontal scrollbar.

Returns the currently configured Drawable for the thumb of the horizontal scroll bar if it exists, null otherwise.

Returns the currently configured Drawable for the track of the horizontal scroll bar if it exists, null otherwise.

Returns this view's identifier.

Gets the mode for determining whether this View is important for accessibility. A view is important for accessibility if it fires accessibility events and if it is reported to accessibility services that query the screen.

Gets the mode for determining whether this view is important for autofill.

See setImportantForAutofill(int) and isImportantForAutofill() for more info about this mode.

Gets the mode for determining whether this view is important for content capture.

See setImportantForContentCapture(int) and isImportantForContentCapture() for more info about this mode.

Returns whether the screen should remain on, corresponding to the current value of KEEP_SCREEN_ON.

Return the global KeyEvent.DispatcherState for this view's window. Returns null if the view is not currently attached to the window. Normally you will not need to use this directly, but just use the standard high-level event callbacks like onKeyDown(int,android.view.KeyEvent).

Gets the id of a view for which this view serves as a label for accessibility purposes.

Indicates what type of layer is currently associated with this view. By default a view does not have a layer, and the layer type is LAYER_TYPE_NONE. Refer to the documentation of setLayerType(int,android.graphics.Paint) for more information on the different types of layers.

Returns the resolved layout direction for this view.

Get the LayoutParams associated with this view. All views should have layout parameters. These supply parameters to the parent of this view specifying how it should be arranged. There are many subclasses of ViewGroup.LayoutParams, and these correspond to the different subclasses of ViewGroup that are responsible for arranging their children. This method may return null if this View is not attached to a parent ViewGroup or setLayoutParams(android.view.ViewGroup.LayoutParams) was not invoked successfully. When a View is attached to a parent ViewGroup, this method must not return null.

Left position of this view relative to its parent.

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.

Amount by which to extend the left fading region. Called only when isPaddingOffsetRequired() returns true.

Sets r to the coordinates of the non-clipped area of this view relative to the top left corner of the view.

If the view is clipped on the left or top, the left and top coordinates are offset from 0 by the clipped amount. For example, if the view is off screen 50px on the left and 30px at the top, the left and top coordinates are 50 and 30 respectively.

If the view is clipped on the right or bottom, the right and bottom coordinates are reduced by the clipped amount. For example, if the view is off screen 40px on the right and 20px at the bottom, the right coordinate is the view width - 40, and the bottom coordinate is the view height - 20.

Gets the coordinates of this view in the coordinate space of the Surface that contains the view.

In multiple-screen scenarios, if the surface spans multiple screens, the coordinate space of the surface also spans multiple screens.

After the method returns, the argument array contains the x and y coordinates of the view relative to the view's left and top edges, respectively.

Gets the coordinates of this view in the coordinate space of the window that contains the view, irrespective of system decorations.

In multi-window mode, the origin of the coordinate space is the top left corner of the window that contains the view. In full screen mode, the origin is the top left corner of the device screen.

In multiple-screen scenarios, if the app spans multiple screens, the coordinate space also spans multiple screens. But if the app is restricted to a single screen, the coordinate space includes only the screen on which the app is running.

After the method returns, the argument array contains the x and y coordinates of the view relative to the view's left and top edges, respectively.

Gets the coordinates of this view in the coordinate space of the device screen, irrespective of system decorations and whether the system is in multi-window mode.

In multi-window mode, the coordinate space encompasses the entire device screen, ignoring the bounds of the app window. For example, if the view is in the bottom portion of a horizontal split screen, the top edge of the screen—not the top edge of the window—is the origin from which the y-coordinate is calculated.

In multiple-screen scenarios, the coordinate space can span screens. For example, if the app is spanning both screens of a dual-screen device and the view is located on the right-hand screen, the x-coordinate is calculated from the left edge of the left-hand screen to the left edge of the view. When the app is restricted to a single screen in a multiple-screen environment, the coordinate space includes only the screen on which the app is running.

After the method returns, the argument array contains the x and y coordinates of the view relative to the view's left and top edges, respectively.

The transform matrix of this view, which is calculated based on the current rotation, scale, and pivot properties.

Like getMeasuredHeightAndState(), but only returns the raw height component (that is the result is masked by MEASURED_SIZE_MASK).

Return the full height measurement information for this view as computed by the most recent call to measure(int,int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use getHeight() to see how high a view is after layout.

Return only the state bits of getMeasuredWidthAndState() and getMeasuredHeightAndState(), combined into one integer. The width component is in the regular bits MEASURED_STATE_MASK and the height component is at the shifted bits MEASURED_HEIGHT_STATE_SHIFT>>MEASURED_STATE_MASK.

Like getMeasuredWidthAndState(), but only returns the raw width component (that is the result is masked by MEASURED_SIZE_MASK).

Return the full width measurement information for this view as computed by the most recent call to measure(int,int). This result is a bit mask as defined by MEASURED_SIZE_MASK and MEASURED_STATE_TOO_SMALL. This should be used during measurement and layout calculations only. Use getWidth() to see how wide a view is after layout.

Returns the minimum height of the view.

Returns the minimum width of the view.

Gets the id of the root of the next keyboard navigation cluster.

Gets the id of the view to use when the next focus is FOCUS_DOWN.

Gets the id of the view to use when the next focus is FOCUS_FORWARD.

Gets the id of the view to use when the next focus is FOCUS_LEFT.

Gets the id of the view to use when the next focus is FOCUS_RIGHT.

Gets the id of the view to use when the next focus is FOCUS_UP.

Returns the focus-change callback registered for this view.

Returns the current ViewOutlineProvider of the view, which generates the Outline that defines the shape of the shadow it casts, and enables outline clipping.

Returns the over-scroll mode for this view. The result will be one of OVER_SCROLL_ALWAYS, OVER_SCROLL_IF_CONTENT_SCROLLS (allow over-scrolling only if the view content is larger than the container), or OVER_SCROLL_NEVER.

Returns the overlay for this view, creating it if it does not yet exist. Adding drawables to the overlay will cause them to be displayed whenever the view itself is redrawn. Objects in the overlay should be actively managed: remove them when they should not be displayed anymore. The overlay will always have the same size as its host view.

Note: Overlays do not currently work correctly with SurfaceView or TextureView; contents in overlays for these types of views may not display correctly.

Returns the bottom padding of this view. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the end padding of this view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the left padding of this view. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the right padding of this view. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the start padding of this view depending on its resolved layout direction. If there are inset and enabled scrollbars, this value may include the space required to display the scrollbars as well.

Returns the top padding of this view.

Gets the parent of this view. Note that the parent is a ViewParent and not necessarily a View.

Gets the parent for accessibility purposes. Note that the parent for accessibility is not necessary the immediate parent. It is the first predecessor that is important for accessibility.

Returns the callback that has previously been set up on this view through the setPendingCredentialRequest API. If the return value is null, that means no callback, or request, has been set on the view and no CredentialManager flow will be invoked when this view is focused. Traditioanl autofill flows will still work, and autofillable content will still be returned through the autofill(android.view.autofill.AutofillValue) )} API.

See setPendingCredentialRequest for more info.

Returns the GetCredentialRequest associated with the view. If the return value is null, that means no request has been set on the view and no CredentialManager flow will be invoked when this view is focused. Traditioanl autofill flows will still work, autofilling content if applicable, from the active android.service.autofill.AutofillService on the device.

See setPendingCredentialRequest for more info.

The x location of the point around which the view is rotated and scaled.

The y location of the point around which the view is rotated and scaled.

Gets the mouse pointer icon for the current view.

Returns the MIME types accepted by performReceiveContent for this view, as configured via setOnReceiveContentListener. By default returns null.