* Adapter class for implementing {@link VelocityTracker} interface * for {@link android.view.VelocityTracker} class. */

Holds information about a smooth scroll request by a {@link SmoothScroller}.

Base class for an Adapter <p>Adapters provide a binding from an app-specific data set to views that are displayed within a {@link RecyclerView}.</p>

Observer base class for watching changes to an {@link Adapter}. See {@link Adapter#registerAdapterDataObserver(AdapterDataObserver)}.

Helper class that can enqueue and process adapter update operations. <p> To support animations, RecyclerView presents an older version the Adapter to

ListUpdateCallback that dispatches update events to the given adapter. @see DiffUtil.DiffResult#dispatchUpdatesTo(RecyclerView.Adapter)

Data class to hold the information about an anchor position which is used in onLayout call.

Simple data class to keep Anchor information

Configuration object for {@link ListAdapter}, {@link AsyncListDiffer}, and similar background-thread list diffing adapter logic. <p> At minimum, defin

Helper for computing the difference between two lists via {@link DiffUtil} on a background thread. <p> It can be connected to a {@link RecyclerView.Ad

A utility class that supports asynchronous content loading. <p> It can be used to load Cursor data in chunks without querying the Cursor on the UI Thr

A callback implementation that can batch notify events dispatched by the SortedList. <p> This class can be useful if you want to do multiple operation

Wraps a {@link ListUpdateCallback} callback and batches operations that can be merged. <p> For instance, when 2 add operations comes that adds 2 conse

Bitset implementation that provides methods to offset indices.

Builder class for {@link AsyncDifferConfig}. @param <T>

The builder for {@link Config} class.

The class that controls the behavior of the {@link SortedList}. <p> It defines how items should be sorted and how duplicates should be handled. <p> So

This class is the contract between ItemTouchHelper and your application. It lets you control which touch behaviors are enabled per each ViewHolder and

A Callback class used by DiffUtil while calculating the diff between two lists.

Contract between AdapterHelper and RecyclerView.

Callback provided by the user of this class in order to retrieve information about child and parent boundaries.

Array wrapper w/ negative index support. We use this array instead of a regular array so that algorithm is easier to read without too many offsets whe

A callback interface that can be used to alter the drawing order of RecyclerView children. <p> It works using the {@link ViewGroup#getChildDrawingOrde

Helper class to manage children. <p> It wraps a RecyclerView and adds ability to hide some children. There are two sets of methods provided by this cl

An {@link Adapter} implementation that presents the contents of multiple adapters in sequence. <pre> MyAdapter adapter1 = ...; AnotherAdapter adapter

All logic for the {@link ConcatAdapter} is here so that we can clearly see a separation between an adapter implementation and merging logic.

The configuration object for a {@link ConcatAdapter}.

The callback that provides data access for {@link AsyncListUtil}. <p> All methods are called on the background thread.

This implementation of {@link RecyclerView.ItemAnimator} provides basic animations on remove, add, and move events that happen to the items in a Recyc

Default implementation for {@link SpanSizeLookup}. Each item occupies 1 span.

A diagonal is a match in the graph. Rather than snakes, we only record the diagonals in the path.

This class holds the information about the result of a {@link DiffUtil#calculateDiff(Callback, boolean)} call. <p> You can consume the updates in a Di

DiffUtil is a utility class that calculates the difference between two lists and outputs a list of update operations that converts the first list into

DividerItemDecoration is a {@link RecyclerView.ItemDecoration} that can be used as a divider between items of a {@link LinearLayoutManager}. It suppor

* A class that provides the required methods from {@link android.widget.EdgeEffect} * class, of which some operations are replaced by the custom edge

EdgeEffectFactory lets you customize the over-scroll edge effect for RecyclerViews. @see RecyclerView#setEdgeEffectFactory(EdgeEffectFactory)

Class responsible to animate and provide a fast scroller.

We keep information about full span items because they may create gaps in the UI.

A {@link RecyclerView.LayoutManager} implementations that lays out items in a grid. <p> By default, each item occupies 1 span. You can change it by pr

An isolating implementation that ensures the stable ids among adapters do not conflict with each-other. It keeps a mapping for each adapter from its l

This class defines the animations that take place on items as changes are made to the adapter. Subclasses of ItemAnimator can be used to implement cu

This interface is used to inform listeners when all pending or running animations in an ItemAnimator are finished. This can be used, for example, to d

The interface to be implemented by listeners to animation events from this ItemAnimator. This is used internally and is not intended for developers to

Internal listener that manages items after animations finish. This is how items are retained (not recycled) during animations, but allowed to be recyc

Callback for calculating the diff between two non-null items in a list. <p> {@link Callback} serves two roles - list indexing, and item diffing. ItemC

An ItemDecoration allows the application to add a special drawing and layout offset to specific item views from the adapter's data set. This can be us

The default implementation of accessibility delegate for the individual items of the RecyclerView. <p> If you are overriding {@code RecyclerViewAccess

A simple data structure that holds information about an item's bounds. This information is used in calculating item animations. Default implementation

This is a utility class to add swipe to dismiss and drag & drop support to RecyclerView. <p> It works with a RecyclerView and a Callback class, which

Utility class for {@link ItemTouchHelper} which handles item transformations for different API versions. <p/> This class has methods that map to {@lin

Package private class to keep implementations. Putting them inside ItemTouchUIUtil makes them public API, which is not desired in this case.

A <code>LayoutManager</code> is responsible for measuring and positioning item views within a <code>RecyclerView</code> as well as determining the pol

LayoutParams used by GridLayoutManager. <p> Note that if the orientation is {@link #VERTICAL}, the width parameter is ignored and if the orientation i

LayoutParams used by StaggeredGridLayoutManager. <p> Note that if the orientation is {@link #VERTICAL}, the width parameter is ignored and if the orie

{@link android.view.ViewGroup.MarginLayoutParams LayoutParams} subclass for children of {@link RecyclerView}. Custom {@link LayoutManager layout manag

Interface for LayoutManagers to request items to be prefetched, based on position, with specified distance from viewport, which indicates priority. @

Prefetch information associated with a specific RecyclerView.

Helper class that keeps temporary state while {LayoutManager} is filling out the empty space.

Helper class that keeps temporary state while {LayoutManager} is filling out the empty space.

An array of mappings from adapter position to span. This only grows when a write happens and it grows up to the size of the adapter.

A {@link RecyclerView.LayoutManager} implementation which provides similar functionality to {@link android.widget.ListView}.

{@link RecyclerView.SmoothScroller} implementation which uses a {@link LinearInterpolator} until the target position becomes a child of the RecyclerVi

Implementation of the {@link SnapHelper} supporting snapping in either vertical or horizontal orientation. <p> The implementation will snap the center

{@link RecyclerView.Adapter RecyclerView.Adapter} base class for presenting List data in a {@link RecyclerView}, including computing diffs between Lis

Listener for when the current List is updated. @param <T> Type of items in List

An interface that can receive Update operations that are applied to a list. <p> This class can be used together with DiffUtil to detect changes betwee

Wrapper for each adapter in {@link ConcatAdapter}.

Returns {@link RecyclerView#NO_ID} for all positions. In other words, stable ids are not supported.

A Listener interface that can be attached to a RecylcerView to get notified whenever a ViewHolder is attached to or detached from RecyclerView.

This class defines the behavior of fling if the developer wishes to handle it. <p> Subclasses of {@link OnFlingListener} can be used to implement cust

An OnItemTouchListener allows the application to intercept touch events in progress at the view hierarchy level of the RecyclerView before those touch

An OnScrollListener can be added to a RecyclerView to receive messages when a scrolling event has occurred on that RecyclerView. <p> @see RecyclerVie