Best Practices for Android Custom BaseAdapter

Although many new projects are using RecyclerView, many developers still prefer ListView or GridView in some scenarios, and then they need to write many Adapters. When the project team started a new project, a colleague brought a ***Adapter mentioned on the Internet. When using it, it was found that it was very inconvenient even in a single view type when the logic judgment was complicated, not to mention using multiple view types in the adapter. This is just a personal opinion, and it may not grasp the essence. This is a blog post about ***Adapter in the Android Rapid Development Series to create the best ListView GridView Adapter.

Of course, with the use of RecyclerView, there are also many blogs on the Internet about encapsulating RecyclerView's multi-view type Adapter. MultiType 3.0 is a relatively comprehensive Adapter written by a great god. This blog Android Complex Multi-Type List View New Writing Method: MultiType 3.0 has detailed usage. *** The adapter itself is not very convenient to use, so I refer to the implementation of the Adapter in RecyclerView to simply encapsulate the BaseAdapter. The purpose of encapsulation is to write less code and to make the logic look clearer. We know that in the implementation of RecyclerView's Adapter, it separates view creation from data binding, and also separates the search and creation of View. This article mainly introduces how to encapsulate the use of BaseAdapter to be consistent with the use of RecyclerView's Adapter. Since we often use simple view types in Adapter, that is, single-type views, this article encapsulates the single-view type Adapter separately, which uses stricter data type checks than the multi-view type Adapter, and is also much more convenient to use.

Use of Adapter in RecyclerView

When using RecyclerView's Adapter, we first need to inherit a static inner class Adapter of RecyclerView, and then rewrite three methods. In fact, the following three methods must be rewritten because they are all abstract methods.

• getItemCount()
• onBindViewHolder(VH holder, int position)
• onCreateViewHolder(ViewGroup parent, int viewType)

Generally, you can rewrite the above three methods, but if there are multiple view types, in the third method

In the onCreateViewHolder() method, we can also see that there is a parameter called viewType. The function of this parameter is to create different ViewHolders for different viewTypes. Therefore, we need to rewrite a method getItemViewType(int position). The implementation method for multiple view types is very similar to that of BaseAdapter. In BaseAdapter, we need to rewrite a method getViewTypeCount() in addition to this, but this method is not required in the Adapter of RecyclerView.

Simple Type Adapter

 private class MyAdapter extends RecyclerView.Adapter<MyViewHolder> { 
 
 @Override
 public   int getItemCount() {
 return   COUNT ;
 } 
 
 @Override
 public void onBindViewHolder(MyViewHolder holder, int position) {
        holder.textView.setText( "TEXT_" + position);
 } 
 
 @Override
 public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
 View   view = LayoutInflater. from (getApplicationContext()).inflate(R.layout.item_text, parent, false );
        MyViewHolder holder = new MyViewHolder( view );
 return holder;
 } 
 
 } 
 
 private static class MyViewHolder extends RecyclerView.ViewHolder {
    private TextView textView; 
 
 public MyViewHolder( View itemView) {
 super(itemView);
        textView = (TextView) itemView.findViewById(R.id.textView);
 }
 }

Complex Type Adapter

 private class MyAdapter extends RecyclerView.Adapter<ViewHolder> { 
 
 @Override
 public   int getItemCount() {
 return   COUNT ;
 } 
 
 @Override
 public   int getItemViewType( int position) {
 return position % 2 == 0 ? TYPE_IMAGE : TYPE_TEXT;
 } 
 
 @Override
 public void onBindViewHolder(ViewHolder holder, int position) {
 int type = getItemViewType(position);
 switch (type) {
 case TYPE_TEXT:
            ((MyTextHolder) holder).textView.setText( "TEXT_" + position);
 break;
 case TYPE_IMAGE:
            ((MyImageHolder) holder).imageView.setImageResource(R.drawable.image);
 break;
 }
 } 
 
 @Override
 public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
 View   view ;
        ViewHolder holder = null ;
 switch (viewType) {
 case TYPE_TEXT:
 view = LayoutInflater. from (getApplicationContext()).inflate(R.layout.item_text, parent, false );
            holder = new MyTextHolder( view );
 break;
 case TYPE_IMAGE:
 view = LayoutInflater. from (getApplicationContext()).inflate(R.layout.item_image, parent, false );
            holder = new MyImageHolder( view );
 break;
 }
 return holder;
 }
 } 
 
 private class MyTextHolder extends RecyclerView.ViewHolder {
    private TextView textView; 
 
 public MyTextHolder( View itemView) {
 super(itemView);
        textView = (TextView) itemView.findViewById(R.id.textView);
 }
 } 
 
 private class MyImageHolder extends ViewHolder {
    private ImageView imageView; 
 
 public MyImageHolder( View itemView) {
 super(itemView);
        imageView = (ImageView) itemView.findViewById(R.id.imageView);
 }
 }

Custom BaseAdapter

Before customizing the base class, let's do a brief analysis. We need to customize an Adapter that supports a single view, and also customize an Adapter that supports multiple view types. Both classes must inherit BaseAdapter. First, extract the common part of the two classes and define it as MyAdapter.

 public abstract class MyAdapter<T> extends BaseAdapter { 
 
    protected List<T> dataList = new ArrayList<>();
    protected Context context;
    protected LayoutInflater inflater; 
 
 public MyAdapter(Context context) {
        this.context = context;
        inflater = LayoutInflater. from (context);
 } 
 
 public void setDataList(List<T> dataList) {
        this.dataList = dataList;
        notifyDataSetChanged();
 } 
 
 @Override
 public   int getCount() {
        if ( null == dataList) {
 return 0;
 }
 return dataList.size () ;
 } 
 
 @Override
 public T getItem( int position) {
 return dataList.get(position);
 } 
 
 @Override
 public long getItemId( int position) {
 return position;
 } 
 
 }

There is no getView() method in the Adapter implementation of RecyclerView. Let's analyze how to split the getView() method. Generally, we implement the getView() method in the following process.

 public   View getView( int position, View convertView, ViewGroup parent) {
    ViewHolder holder = null ;
    if ( null == convertView) {
 //Fill the layout
        convertView=inflater.inflate(R.layout.item_layout, parent, false );
        holder = new ViewHolder();
 //Query the control by ID
        holder.textView=(TextView)convertView.findViewById(R.id.textView);
        holder.imageView=(ImageView)convertView.findViewById(R.id.imageView);
        convertView .setTag(holder);
 } else {
        holder = (ViewHolder) convertView.getTag();
 }
 //Assignment logic
 return convertView;
 }
 //An empty ViewHolder
 public   static class ViewHolder{
 TextView textView;
 ImageView imageView;
 }

Isn't interface-oriented programming a popular programming method in Java? In Android development, there is also a development method called Holder-oriented programming. The above code is the traditional way to implement ViewHolder. In terms of implementation, it does not do anything, but just acts as a carrier to carry the controls we need. We let ViewHolder do more things, and put most of the logic that it needs to do when convertView==null into ViewHolder.

 public class ViewHolder {
    private final View itemView; 
 
 public ViewHolder( View itemView) {
        if ( null == itemView) {
            throw new IllegalArgumentException( "itemView must not be null" );
 } else {
            this.itemView = itemView;
            itemView.setTag(this);
 }
 } 
 
 public   View getItemView() {
 return itemView;
 }
 }

The itemView in ViewHolder is the convertView in the getView() method, which happens to be the root View of the item, similar to the itemView in the ViewHolder construction method in RecyclerView. Since different views need to create different ViewHolders, we can set the method for creating ViewHolder as an abstract method and expose it. In addition, when assigning values, we also need to assign values ​​according to specific business, and also set an abstract method.

 public abstract class SimpleAdapter<T,VH extends ViewHolder> extends MyAdapter<T> { 
 
 public SimpleAdapter(Context context) {
 super(context);
 } 
 
 public   View getView( int position, View convertView, ViewGroup parent) {
 VH holder = null ;
        if ( null == convertView) {
            holder = onCreateViewHolder(parent);
            convertView = holder.getItemView();
 } else {
            holder = (VH) convertView.getTag();
 }
        onBindViewHolder(holder, position);
 return convertView;
 } 
 
 public abstract void onBindViewHolder(VH holder, int position); 
 
 public abstract VH onCreateViewHolder(ViewGroup parent); 
 
 }

When setting up an Adapter with multiple view types, you only need to pass in an additional viewType parameter when creating the ViewHolder.

 public abstract class MultiAdapter<T> extends MyAdapter<T> { 
 
 public MultiAdapter(Context context) {
 super(context);
 } 
 
 @Override
 public   View getView( int position, View convertView, ViewGroup parent) {
        ViewHolder holder = null ;
        if ( null == convertView) {
            holder = onCreateViewHolder(parent, getItemViewType(position));
            convertView = holder.getItemView();
 } else {
            holder = (ViewHolder) convertView.getTag();
 }
        onBindViewHolder(holder, position);
 return convertView;
 } 
 
 public abstract void onBindViewHolder(ViewHolder holder, int position); 
 
 public abstract ViewHolder onCreateViewHolder(ViewGroup parent, int viewType); 
 
 }

Use of custom BaseAdapter

Single view type SimpleAdapter use

 public class TextAdapter extends SimpleAdapter<String, TextAdapter.TextHolder> { 
 
 public TextAdapter(Context context) {
 super(context);
 } 
 
 @Override
 public void onBindViewHolder(TextHolder holder, int position) {
        holder.textView.setText(getItem(position));
 } 
 
 @Override
 public TextHolder onCreateViewHolder(ViewGroup parent) {
 View convertView=inflater.inflate(R.layout.item_text, parent, false );
 return new TextHolder(convertView);
 } 
 
 static class TextHolder extends ViewHolder{ 
 
 public TextView textView; 
 
 public TextHolder( View itemView) {
 super(itemView);
            textView=(TextView) itemView.findViewById(R.id.textView);
 }
 }
 }

Here we use two generics, one is the data type String supported in ViewHolder, and the other is the ViewHolder we need to create, so that the return value of the onCreateViewHolder method will automatically return our custom ViewHolder. For more information about generics, please refer to Java Generic Usage Analysis. The use of single view type Adapter is much more convenient than RecyclerView's Adapter.

Use of multiple view types

 public class RichAdapter extends MultiAdapter<String> { 
 
    private static final int TEXT = 0;
    private static final int PIC = 1; 
 
 public RichAdapter(Context context) {
 super(context);
 } 
 
 @Override
 public   int getViewTypeCount() {
 return 2;
 } 
 
 @Override
 public   int getItemViewType( int position) {
        if (position % 3 == 0) {
 return PIC;
 } else {
 return TEXT;
 }
 } 
 
 @Override
 public void onBindViewHolder(ViewHolder holder, int position) {
        switch (getItemViewType(position)) {
 case TEXT:
            TextHolder textHolder=(TextHolder) holder;
            textHolder.textView.setText(getItem(position));
 break;
 case PIC:
            ImageHolder imageHolder=(ImageHolder) holder;
            imageHolder.imageView.setImageResource(R.drawable.image);
 break;
 }
 } 
 
 @Override
 public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
 View itemView = null ;
        ViewHolder holder = null ;
 switch (viewType) {
 case TEXT:
            itemView = inflater.inflate(R.layout.item_text, parent, false );
            holder = new TextHolder(itemView);
 break;
 case PIC:
            itemView = inflater.inflate(R.layout.item_image, parent, false );
            holder = new ImageHolder(itemView);
 break;
 }
 return holder;
 } 
 
    private static class TextHolder extends ViewHolder {
 TextView textView; 
 
 public TextHolder( View itemView) {
 super(itemView);
            textView = (TextView) itemView.findViewById(R.id.textView);
 } 
 
 } 
 
    private static class ImageHolder extends ViewHolder {
 ImageView imageView; 
 
 public ImageHolder( View itemView) {
 super(itemView);
            imageView = (ImageView) itemView.findViewById(R.id.imageView);
 }
 }
 }

The usage here is almost identical to that of RecyclerView. The only difference is that an additional getViewTypeCount() method is written. This method must be overridden when ListView or GridView uses BaseAdapter to implement multiple types of views.