:pensive: Due to the nature of my job and growing popularity of Jetpack Compose, I lack the motivation to keep this project alive.

<br/>

Alt text

Recyclerview is one of the powerful widgets inside android framework. But creating adapters with multiple view types is always exhausting. Not anymore. MultiViewAdapter makes it easy for you to create adapter with multiple view types easily. Using the library you will be able to build composable view holders, which can be re-used across your app. Apart from this, MultiViewAdapter adds many other useful features into the library as add-ons.

:tada::tada: MultiViewAdapter v3.0 supports AndroidX. v3.0 is identical to v2.0 except for package name changes and androidx support.

Why this library
Feature Showcase
Gradle Dependency
Core Concepts
Basic Usage
Advanced Usage
Learn More
Changelog
Contribution
Credits
Hall of fame
License

Why this library?

Have you ever displayed multiple view types inside a single adapter? Have you ever added selection mode to an adapter? Have you ever set different span size to different items inside a single adapter? Have you ever added swipe-to-dismiss / drag & drop / infinite scrolling features to your adapter?

If you answered yes, then you must know how hard it is to do any one of these. What if you had to add all of these inside a single adapter. Phew.

Problems with default adapter

In default adapter approach, code is not re-usable as it is.
If you have to add multiple viewtypes the code grows painfully.
If the data needs to be updated, its hard to write the updation logic and call the correct notify method.

Problems with similar libraries

To solve the above problems, you can also use a different library or libraries. But such libraries have a common restrictions - Your data model will be polluted with the view logic.

Your data objects should extend/implement from library's model, which can interfere with your object hierarchy.
View holder creation and binding has to be written inside the data model. You are forced to keep layout and view references inside the model class itself.
For complex lists, generic notifyDataSetChanged method will be called during updation. Also these libraries don’t take advantage of DiffUtil.
You have to write switch cases, if you want to have different item-decorations/span-size/selection-modes/expansion-modes for different view types.
You lose the 'type' information when accessing objects ie., you need to cast the object every time you need it.

MultiViewAdapter solves all of these requirements. The library was specifically designed in a way to not interfere with your object modeling and hierarchy.

Feature Showcase

Here are the few features which are possible with this library.

Multiple Viewtypes | Multiple Spans | Other Features -------------------- | -------------------- | -------------------- | | Other

Selection | Item Expansion | Section Expansion -------------------- | -------------------- | -------------------- | |

Gradle Dependency

The library is available via JCenter. JCenter is the default maven repository used by Android Studio. The minimum API level supported by this library is API 14.

Adding Library

dependencies {
    implementation 'dev.ahamed.mva2:adapter:2.0.0'
}

Adding Extension

dependencies {
    implementation 'dev.ahamed.mva2:ext-databinding:2.0.0'  // DataBinding
    implementation 'dev.ahamed.mva2:ext-decorator:2.0.0'    // Decorators
    implementation 'dev.ahamed.mva2:ext-diffutil-rx:2.0.0'  // RxDiffUtil
}

Using Snapshot Version

Just add '-SNAPSHOT' to the version name

dependencies {
    implementation 'dev.ahamed.mva2:adapter:2.0.0-SNAPSHOT' // Library
}

To use the above snapshot version add the following to your project's gradle file

allprojects {
    repositories {
        maven {
            url 'https://oss.jfrog.org/artifactory/oss-snapshot-local'
        }
    }
}

Core Concepts

Core mantra of MultiViewAdapter - Separation of view logic from data management logic. You get two different components which are :

Section - Component to hold your data. All data related updates will run here and proper notify method will be called on the adapter.
ItemBinder - Component which creates and binds your view holder. All view related logic should go here.

Section

Section is the building block for MultiViewAdapter. Section will hold your data which needs to be displayed inside the recyclerview - data can be a single item or list of items. When the underlying data is changed the section will calculate the diff and call the correct notify method inside the adapter. You can add as many as Section to an adapter.

How Section Works GIF

There are different types of sections.

|Name|Description| |---|---| |ItemSection|Section to display single item| |ListSection|Section to display list of items| |HeaderSection|Section to display list of items along with a header| |NestedSection|Section which can host other section| |TreeSection|Section which can display items in tree fashion. Ex: Comment list|

ItemBinder

ItemBinder is the class where all view related code should be written. ItemBinder is responsible for creating and binding view holders. The method signatures are kept close to the default RecyclerView.Adapter method signatures. For each viewtype inside the recyclerview, you need to create an ItemBinder.

ItemBinder allows you to have different decoration for different view types. Apart from this, with ItemBinder you will be able to add Swipe-to-dismiss, drag and drop features.

Basic Usage

Lets create an adapter which displays a list of cars. Follow these steps.

You need to create an ItemBinder for your model. ItemBinder is responsible for creating and binding your view holders. Following is the code snippet of ItemBinder for CarModel class.

CarBinder

public class CarBinder extends ItemBinder<CarModel, CarBinder.CarViewHolder> {

  @Override public CarViewHolder createViewHolder(ViewGroup parent) {
      return new CarViewHolder(inflate(R.layout.item_car, parent));
  }

  @Override public boolean canBindData(Object item) {
      return item instanceof CarModel;
  }

  @Override public void bindViewHolder(CarViewHolder holder, CarModel item) {
      holder.tvCarName.setText(item.getName());
  }

  static class CarViewHolder extends ItemViewHolder<CarModel> {

    TextView tvCarName;

    public CarViewHolder(View itemView) {
        super(itemView);
        tvCarName = findViewById(R.id.tv_car_name);
    }
  }
}

Now create an adapter and use the ItemBinder created above. Since we are displaying a list of items we need to create an ListSection object and add the data items to it. Now add this section to adapter. Done.

Inside Activity/Fragment

class CarListActivity extends Activity {
  private RecyclerView recyclerView;
  private List<CarModel> cars;

  public void initViews() {

      // Create Adapter
      MultiViewAdapter adapter = new MultiViewAdapter();
      recyclerView.setAdapter(adapter);

      // Register Binder
      adapter.registerBinders(new CarItemBinder());

      // Create Section and add items
      ListSection<YourModel> listSection = new ListSection<>();
      listSection.addAll(cars);

      // Add Section to the adapter
      adapter.addSection(listSection);
  }
}

Yay!! We are done.

Advanced Usage

Multiple viewtypes

The USP of MultiViewAdapter is adding multiple viewtypes to a single adapter easily. For each view type you need to create an ItemBinder and register it with the adapter. You don't need to manage the viewtypes yourself or write crazy if-else-if conditions.

    adapter.registerBinders(new Binder1(), new Binder2(), ...);

Multiple Sections

Sections are building blocks of MultiViewAdapter. You can add as many as sections to the adapter and you can nest the sections within another section as well. Each section represents a data set. If you want to display multiple data set inside a single adapter you can do so by adding any number of sections.

    adapter.addSection(new ItemSection());
    adapter.addSection(new ListSection());
    adapter.addSection(new NestedSection());
    // And so on...

MultiViewAdapter

Install / Use

README

Contents