Summary: Protected Ctors | Methods | Protected Methods | Inherited Methods

ListAdapter

Kotlin |Java

public abstract class ListAdapter
extends Adapter<VH extends RecyclerView.ViewHolder>

java.lang.Object
↳	androidx.recyclerview.widget.RecyclerView.Adapter<VH extends androidx.recyclerview.widget.RecyclerView.ViewHolder>
	↳	androidx.recyclerview.widget.ListAdapter<T, VH extends androidx.recyclerview.widget.RecyclerView.ViewHolder>

RecyclerView.Adapter base class for presenting List data in a RecyclerView, including computing diffs between Lists on a background thread.

This class is a convenience wrapper around AsyncListDiffer that implements Adapter common default behavior for item access and counting.

While using a LiveData<List> is an easy way to provide data to the adapter, it isn't required - you can use submitList(List) when new lists are available.

A complete usage pattern with Room would look like this:

 @Dao
 interface UserDao {
     @Query("SELECT * FROM user ORDER BY lastName ASC")
     public abstract LiveData<List<User>> usersByLastName();
 }

 class MyViewModel extends ViewModel {
     public final LiveData<List<User>> usersList;
     public MyViewModel(UserDao userDao) {
         usersList = userDao.usersByLastName();
     }
 }

 class MyActivity extends AppCompatActivity {
     @Override
     public void onCreate(Bundle savedState) {
         super.onCreate(savedState);
         MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
         RecyclerView recyclerView = findViewById(R.id.user_list);
         UserAdapter<User> adapter = new UserAdapter();
         viewModel.usersList.observe(this, list -> adapter.submitList(list));
         recyclerView.setAdapter(adapter);
     }
 }

 class UserAdapter extends ListAdapter<User, UserViewHolder> {
     public UserAdapter() {
         super(User.DIFF_CALLBACK);
     }
     @Override
     public void onBindViewHolder(UserViewHolder holder, int position) {
         holder.bindTo(getItem(position));
     }
     public static final DiffUtil.ItemCallback<User> DIFF_CALLBACK =
             new DiffUtil.ItemCallback<User>() {
         @Override
         public boolean areItemsTheSame(
                 @NonNull User oldUser, @NonNull User newUser) {
             // User properties may have changed if reloaded from the DB, but ID is fixed
             return oldUser.getId() == newUser.getId();
         }
         @Override
         public boolean areContentsTheSame(
                 @NonNull User oldUser, @NonNull User newUser) {
             // NOTE: if you use equals, your object must properly override Object#equals()
             // Incorrectly returning false here will result in too many animations.
             return oldUser.equals(newUser);
         }
     }
 }

Advanced users that wish for more control over adapter behavior, or to provide a specific base class should refer to AsyncListDiffer, which provides custom mapping from diff events to adapter positions.

Summary

Protected constructors
`ListAdapter(ItemCallback<T> diffCallback)`
`ListAdapter(AsyncDifferConfig<T> config)`

Public methods
`List<T>`	`getCurrentList()` Get the current List - any diffing to present this list has already been computed and dispatched via the ListUpdateCallback.
`int`	`getItemCount()` Returns the total number of items in the data set held by the adapter.
`void`	`onCurrentListChanged(List<T> previousList, List<T> currentList)` Called when the current List is updated.
`void`	`submitList(List<T> list)` Submits a new list to be diffed, and displayed.
`void`	`submitList(List<T> list, Runnable commitCallback)` Set the new list to be displayed.

Protected methods
`T`	`getItem(int position)`

Inherited methods

From class


        
          androidx.recyclerview.widget.RecyclerView.Adapter

`final void`	`bindViewHolder(VH holder, int position)` This method internally calls `onBindViewHolder(ViewHolder, int)` to update the `RecyclerView.ViewHolder` contents with the item at the given position and also sets up some private fields to be used by RecyclerView.
`final VH`	`createViewHolder(ViewGroup parent, int viewType)` This method calls `onCreateViewHolder(ViewGroup, int)` to create a new `RecyclerView.ViewHolder` and initializes some private fields to be used by RecyclerView.
`int`	`findRelativeAdapterPositionIn(Adapter<? extends RecyclerView.ViewHolder> adapter, RecyclerView.ViewHolder viewHolder, int localPosition)` Returns the position of the given `RecyclerView.ViewHolder` in the given `RecyclerView.Adapter`.
`abstract int`	`getItemCount()` Returns the total number of items in the data set held by the adapter.
`long`	`getItemId(int position)` Return the stable ID for the item at `position`.
`int`	`getItemViewType(int position)` Return the view type of the item at `position` for the purposes of view recycling.
`final RecyclerView.Adapter.StateRestorationPolicy`	`getStateRestorationPolicy()` Returns when this Adapter wants to restore the state.
`final boolean`	`hasObservers()` Returns true if one or more observers are attached to this adapter.
`final boolean`	`hasStableIds()` Returns true if this adapter publishes a unique `long` value that can act as a key for the item at a given position in the data set.
`final void`	`notifyDataSetChanged()` Notify any registered observers that the data set has changed.
`final void`	`notifyItemChanged(int position, Object payload)` Notify any registered observers that the item at `position` has changed with an optional payload object.
`final void`	`notifyItemChanged(int position)` Notify any registered observers that the item at `position` has changed.
`final void`	`notifyItemInserted(int position)` Notify any registered observers that the item reflected at `position` has been newly inserted.
`final void`	`notifyItemMoved(int fromPosition, int toPosition)` Notify any registered observers that the item reflected at `fromPosition` has been moved to `toPosition`.
`final void`	`notifyItemRangeChanged(int positionStart, int itemCount, Object payload)` Notify any registered observers that the `itemCount` items starting at position `positionStart` have changed.
`final void`	`notifyItemRangeChanged(int positionStart, int itemCount)` Notify any registered observers that the `itemCount` items starting at position `positionStart` have changed.
`final void`	`notifyItemRangeInserted(int positionStart, int itemCount)` Notify any registered observers that the currently reflected `itemCount` items starting at `positionStart` have been newly inserted.
`final void`	`notifyItemRangeRemoved(int positionStart, int itemCount)` Notify any registered observers that the `itemCount` items previously located at `positionStart` have been removed from the data set.
`final void`	`notifyItemRemoved(int position)` Notify any registered observers that the item previously located at `position` has been removed from the data set.
`void`	`onAttachedToRecyclerView(RecyclerView recyclerView)` Called by RecyclerView when it starts observing this Adapter.
`abstract void`	`onBindViewHolder(VH holder, int position)` Called by RecyclerView to display the data at the specified position.
`void`	`onBindViewHolder(VH holder, int position, List<Object> payloads)` Called by RecyclerView to display the data at the specified position.
`abstract VH`	`onCreateViewHolder(ViewGroup parent, int viewType)` Called when RecyclerView needs a new `RecyclerView.ViewHolder` of the given type to represent an item.
`void`	`onDetachedFromRecyclerView(RecyclerView recyclerView)` Called by RecyclerView when it stops observing this Adapter.
`boolean`	`onFailedToRecycleView(VH holder)` Called by the RecyclerView if a ViewHolder created by this Adapter cannot be recycled due to its transient state.
`void`	`onViewAttachedToWindow(VH holder)` Called when a view created by this adapter has been attached to a window.
`void`	`onViewDetachedFromWindow(VH holder)` Called when a view created by this adapter has been detached from its window.
`void`	`onViewRecycled(VH holder)` Called when a view created by this adapter has been recycled.
`void`	`registerAdapterDataObserver(RecyclerView.AdapterDataObserver observer)` Register a new observer to listen for data changes.
`void`	`setHasStableIds(boolean hasStableIds)` Indicates whether each item in the data set can be represented with a unique identifier of type `Long`.
`void`	`setStateRestorationPolicy(RecyclerView.Adapter.StateRestorationPolicy strategy)` Sets the state restoration strategy for the Adapter.
`void`	`unregisterAdapterDataObserver(RecyclerView.AdapterDataObserver observer)` Unregister an observer currently listening for data changes.

From class


        
          java.lang.Object

`Object`	`clone()`
`boolean`	`equals(Object arg0)`
`void`	`finalize()`
`final Class<?>`	`getClass()`
`int`	`hashCode()`
`final void`	`notify()`
`final void`	`notifyAll()`
`String`	`toString()`
`final void`	`wait(long arg0, int arg1)`
`final void`	`wait(long arg0)`
`final void`	`wait()`

Protected constructors

protected ListAdapter (ItemCallback<T> diffCallback)

Parameters
`diffCallback`	`ItemCallback`

protected ListAdapter (AsyncDifferConfig<T> config)

Parameters
`config`	`AsyncDifferConfig`

Public methods

getCurrentList

public List<T> getCurrentList ()

Get the current List - any diffing to present this list has already been computed and dispatched via the ListUpdateCallback.

If a null List, or no List has been submitted, an empty list will be returned.

The returned list may not be mutated - mutations to content must be done through submitList(List).

Returns
`List<T>`	The list currently being displayed.

See also:

onCurrentListChanged(List, List)

getItemCount

public int getItemCount ()

Returns the total number of items in the data set held by the adapter.

Returns
`int`	The total number of items in this adapter.

onCurrentListChanged

public void onCurrentListChanged (List<T> previousList, 
                List<T> currentList)

Called when the current List is updated.

If a null List is passed to submitList(List), or no List has been submitted, the current List is represented as an empty List.

Parameters
`previousList`	`List`: List that was displayed previously.
`currentList`	`List`: new List being displayed, will be empty if `null` was passed to `submitList(List)`.

See also:

getCurrentList()

submitList

public void submitList (List<T> list)

Submits a new list to be diffed, and displayed.

If a list is already being displayed, a diff will be computed on a background thread, which will dispatch Adapter.notifyItem events on the main thread.

Parameters
`list`	`List`: The new list to be displayed.

submitList

public void submitList (List<T> list, 
                Runnable commitCallback)

Set the new list to be displayed.

If a List is already being displayed, a diff will be computed on a background thread, which will dispatch Adapter.notifyItem events on the main thread.

The commit callback can be used to know when the List is committed, but note that it may not be executed. If List B is submitted immediately after List A, and is committed directly, the callback associated with List A will not be run.

Parameters
`list`	`List`: The new list to be displayed.
`commitCallback`	`Runnable`: Optional runnable that is executed when the List is committed, if it is committed.

Protected methods

getItem

protected T getItem (int position)

Parameters
`position`	`int`

Returns
`T`