FlexibleAdapter | Fast and versatile Adapter for RecyclerView which regroups several features into one library to considerably improve the user experience :) | Android library

class myfragment : Fragment() {
private lateinit var myLayoutAdapter: MultiPurposeListAdapter<*>
private var myItems = mutableListOf<AbstractFlexibleItem<*>>()

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)

    myLayoutAdapter = MultiPurposeListAdapter(myItems, this, true)

    // Prepare the RecyclerView and attach the Adapter to it
    fragment_recycler_view.apply {
        layoutManager = createNewLinearLayoutManager()
        adapter = mIngredientsLayoutAdapter
        setHasFixedSize(false) //Size of RecyclerView will change
    }
}

/******
 * A function to add items
 ******
fun addNewItem(itemToAdd: MyItem) {
    //Note: itemToAdd is from MyItem that extends AbstractFlexibleItem

    // If I try to invoke the addOtem method from the FlexibleAdapter
    // I get a Type mismatch error
    // addItem is not overriden by MultiplePurposeListAdapter!

    myLayoutAdapter.addItem(itemToAdd)  // <- Here I get a Type mismatch error
                                        // Required: Nothing
                                        // Found: MyItem
    }
}

open class MultiPurposeListAdapter<T: AbstractFlexibleItem<*>>
@JvmOverloads constructor(items: List<T>?, listeners: Any? = null, stableIds: Boolean = true)
: FlexibleAdapter<T>(items, listeners, stableIds) {

    // Here we extend the FlexibleAdapter with custom filters
    }

public class FlexibleAdapter<T extends IFlexible> extends AnimatorAdapter {

private List<T> mItems // The main container for ALL items

/**
 * Simply append the provided item to the end of the list.
 * <p>Convenience method of {@link #addItem(int, IFlexible)} with
 * {@code position = getMainItemCount()}.</p>
 *
 * @param item the item to add
 * @return true if the internal list was successfully modified, false otherwise
 */
public boolean addItem(@NonNull T item) {
    return addItem(getItemCount(), item);
}

/**
 * Returns the total number of items in the data set held by the adapter.
 *
 * @return the total number of items (headers and footers INCLUDED) held by the adapter
 */
@Override
public int getItemCount() {
    return mItems.size();
}

/**
 * Inserts the given item at the specified position or Adds the item to the end of the list
 * (no matters if the new position is out of bounds!).
 *
 * @param position position inside the list, if negative, items will be added to the end
 * @param item     the item to add
 * @return true if the internal list was successfully modified, false otherwise
 */
public boolean addItem(@IntRange(from = 0) int position, @NonNull T item) {
    if (item == null) {
        log.e("addItem No item to add!");
        return false;
    }
    log.v("addItem delegates addition to addItems!");
    return addItems(position, Collections.singletonList(item));
}

/**
 * Inserts a set of items at specified position or Adds the items to the end of the list
 * (no matters if the new position is out of bounds!).
 *
 * @param position position inside the list, if negative, items will be added to the end
 * @param items    the set of items to add
 * @return true if the internal list was successfully modified, false otherwise
 */
public boolean addItems(@IntRange(from = 0) int position, @NonNull List<T> items) {
    if (items == null || items.isEmpty()) {
        log.e("addItems No items to add!");
        return false;
    }
    int initialCount = getMainItemCount(); // Count only main items!
    if (position < 0) {
        log.w("addItems Position is negative! adding items to the end");
        position = initialCount + mScrollableHeaders.size();
    }
    // Insert the items properly
    performInsert(position, items, true);
    // Show the headers of new items
    showOrUpdateHeaders(items);
    // Call listener to update EmptyView
    if (!recursive && mUpdateListener != null && !multiRange && initialCount == 0 && getItemCount() > 0) {
        mUpdateListener.onUpdateEmptyView(getMainItemCount());
    }
    return true;
}
}

data class SectionItem(private val title: String, private val headerItem: HeaderItem) :
        AbstractFlexibleItem(),
        ISectionable {


override fun getLayoutRes(): Int = R.layout.section

override fun getHeader(): HeaderItem = headerItem

override fun setHeader(headerItem: HeaderItem) {
}

override fun createViewHolder(view: View?, adapter: FlexibleAdapter<IFlexible<RecyclerView.ViewHolder>>?): ViewHolder = ViewHolder(view, adapter)

override fun bindViewHolder(adapter: FlexibleAdapter<IFlexible<RecyclerView.ViewHolder>>?, holder: ViewHolder?, position: Int, payloads: MutableList<Any>?) {
    holder?.let {
        it.title.text = title
    }
}

class ViewHolder(view: View?, adapter: FlexibleAdapter<*>?) : FlexibleViewHolder(view, adapter) {
    var title: TextView = view?.findViewById(R.id.title)!!
}}

class GradeFragment : BaseFragment(), GradeView {

@Inject
lateinit var presenter: GradePresenter

private val gradeAdapter = FlexibleAdapter<AbstractFlexibleItem<*>>(null, null, true)

companion object {
    fun newInstance() = GradeFragment()
}

override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
    return inflater.inflate(R.layout.fragment_grade, container, false)
}

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)
    presenter.run {
        attachView(this@GradeFragment)
        loadData()
    }
}

override fun initView() {
    gradeAdapter.run {
        isAutoCollapseOnExpand = true
        isAutoScrollOnExpand = true
        setOnUpdateListener { presenter.onUpdateDataList(it) }
        setOnItemClickListener { position ->
            getItem(position).let {
                if (it is GradeItem) {
                    GradeDialog.newInstance(it.grade).show(fragmentManager, it.toString())
                }
            }
        }
    }
    gradeRecycler.run {
        layoutManager = SmoothScrollLinearLayoutManager(context)
        adapter = gradeAdapter
    }
    gradeSwipe.setOnRefreshListener { presenter.loadData(forceRefresh = true) }
}

override fun updateData(data: List<GradeHeader>) {
    gradeAdapter.updateDataSet(data, true)
}

override fun isViewEmpty(): Boolean = gradeAdapter.isEmpty

override fun showEmptyView(show: Boolean) {
    gradeEmpty.visibility = if (show) VISIBLE else GONE
}

override fun showProgress(show: Boolean) {
    gradeProgress.visibility = if (show) VISIBLE else GONE
}

override fun setRefresh(show: Boolean) {
    gradeSwipe.isRefreshing = show
}

class GradePresenter @Inject constructor(
    private val errorHandler: ErrorHandler,
    private val schedulers: SchedulersManager,
    private val gradeRepository: GradeRepository,
    private val sessionRepository: SessionRepository) : BasePresenter<GradeView>(errorHandler) {

override fun attachView(view: GradeView) {
    super.attachView(view)
    view.initView()
}

fun loadData(forceRefresh: Boolean = false) {
    disposable.add(sessionRepository.getSemesters()
            .map { it.single { semester -> semester.current } }
            .flatMap { gradeRepository.getGrades(it, forceRefresh) }
            .map { it.groupBy { grade -> grade.subject } }
            .map { createGradeItems(it) }
            .subscribeOn(schedulers.backgroundThread())
            .observeOn(schedulers.mainThread())
            .doFinally { view?.setRefresh(false) }
            .doOnSuccess { if (it.isEmpty()) view?.showEmptyView(true) }
            .doOnError { view?.run { if (isViewEmpty()) showEmptyView(true) } }
            .subscribe({ view?.updateData(it) }) { errorHandler.proceed(it) })
}

private fun createGradeItems(items: Map<String, List<Grade>>): List<GradeHeader> {
    return items.map {
        val gradesAverage = calcAverage(it.value)
        GradeHeader().apply {
            subject = it.key
            average = view?.run {
                if (gradesAverage == 0f) emptyAverageString()
                else averageString().format(gradesAverage)
            }.orEmpty()
            number = view?.gradeNumberString(it.value.size).orEmpty()
            subItems = (it.value.map { item ->
                GradeItem().apply {
                    grade = item
                    weightString = view?.weightString().orEmpty()
                    valueColor = getValueColor(item.value)
                }
            })
        }
    }
}

fun onUpdateDataList(size: Int) {
    if (size != 0) view?.showProgress(false)
}

package win.network610.yannickg.flexibleadapter_sandbox;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.RecyclerView;

import java.util.ArrayList;
import java.util.List;

import eu.davidea.flexibleadapter.FlexibleAdapter;
import eu.davidea.flexibleadapter.items.IFlexible;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Optional but strongly recommended: Compose the initial list
        List<IFlexible> myItems = getDatabaseList();

// Initialize the Adapter
        FlexibleAdapter<IFlexible> adapter = new FlexibleAdapter<>(myItems);

// Initialize the RecyclerView and attach the Adapter to it as usual
        RecyclerView recyclerView = findViewById(R.id.recyclerView1);
        recyclerView.setAdapter(adapter);
    }

    public List<IFlexible> getDatabaseList() {
        List<IFlexible> list = new ArrayList<>();
        list.add(new MyItem("1", "Hello"));
        list.add(new MyItem("2", "World"));
        list.add(new MyItem("3", "World3"));
        list.add(new MyItem("4", "World4"));
        list.add(new MyItem("5", "World5"));
        list.add(new MyItem("6", "World6"));
        list.add(new MyItem("7", "World7"));
        return list;
    }
}

package win.network610.yannickg.flexibleadapter_sandbox;

import android.view.View;
import android.widget.TextView;

import java.util.List;

import eu.davidea.flexibleadapter.FlexibleAdapter;
import eu.davidea.flexibleadapter.items.AbstractFlexibleItem;
import eu.davidea.flexibleadapter.items.IFlexible;
import eu.davidea.viewholders.FlexibleViewHolder;

/**
 * Where AbstractFlexibleItem implements IFlexible!
 */
public class MyItem extends AbstractFlexibleItem<MyItem.MyViewHolder> {

    private String id;
    private String title;

    public MyItem(String id, String title) {
        this.id = id;
        this.title = title;
    }

    /**
     * When an item is equals to another?
     * Write your own concept of equals, mandatory to implement or use
     * default java implementation (return this == o;) if you don't have unique IDs!
     * This will be explained in the "Item interfaces" Wiki page.
     */
    @Override
    public boolean equals(Object inObject) {
        if (inObject instanceof MyItem) {
            MyItem inItem = (MyItem) inObject;
            return this.id.equals(inItem.id);
        }
        return false;
    }

    /**
     * You should implement also this method if equals() is implemented.
     * This method, if implemented, has several implications that Adapter handles better:
     * - The Hash, increases performance in big list during Update & Filter operations.
     * - You might want to activate stable ids via Constructor for RV, if your id
     *   is unique (read more in the wiki page: "Setting Up Advanced") you will benefit
     *   of the animations also if notifyDataSetChanged() is invoked.
     */
    @Override
    public int hashCode() {
        return id.hashCode();
    }

    /**
     * For the item type we need an int value: the layoutResID is sufficient.
     */
    @Override
    public int getLayoutRes() {
        return R.layout.item_flexible;
    }

    /**
     * Delegates the creation of the ViewHolder to the user (AutoMap).
     * The infladed view is already provided as well as the Adapter.
     */
    @Override
    public MyViewHolder createViewHolder(View view, FlexibleAdapter<IFlexible> adapter) {
        return new MyViewHolder(view, adapter);
    }

    /**
     * The Adapter and the Payload are provided to perform and get more specific
     * information.
     */
    @Override
    public void bindViewHolder(FlexibleAdapter<IFlexible> adapter, MyViewHolder holder,
                               int position,
                               List<Object> payloads) {
        holder.mTitle.setText(title);
        // Title appears disabled if item is disabled
        holder.mTitle.setEnabled(isEnabled());
    }

    /**
     * The ViewHolder used by this item.
     * Extending from FlexibleViewHolder is recommended especially when you will use
     * more advanced features.
     */
    public class MyViewHolder extends FlexibleViewHolder {

        public TextView mTitle;

        public MyViewHolder(View view, FlexibleAdapter adapter) {
            super(view, adapter);
            mTitle = (TextView) view.findViewById(R.id.title);
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/recyclerView1"
        android:layout_marginBottom="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <android.support.v7.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >

            <TextView
                android:id="@+id/title"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:text="TextView" />
    </android.support.v7.widget.CardView>

</android.support.constraint.ConstraintLayout>