BaseAdapter.java

import android.os.Handler;
import android.support.v7.widget.RecyclerView;

import com.warmice.android.pathfinderrulebooks.ui.listener.TransactionListener;

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

/**
 * Created by gabriel on 7/19/15.
 */
public abstract class BaseAdapter<T, V extends RecyclerView.ViewHolder> extends RecyclerView.Adapter<V> {

    private List<T> list = new ArrayList<>();
    private TransactionListener transactionListener;
    private boolean adapterHasUpdated = false;

    @Override
    public int getItemCount() {
        return list.size();
    }

    public List<T> getList() {
        return list;
    }

    public T getItemAt(int position) {
        return list.get(position);
    }

    public Boolean listIsEqualTo(List<T> list) {
        boolean sizesAreEqual = list.size() == this.list.size();
        if (!sizesAreEqual) {
            return false;
        }

        for (int i = 0; i < list.size(); i++) {
            boolean currentItemsAreNotEqual = !this.list.get(i).equals(list.get(i));
            if (currentItemsAreNotEqual) {
                return false;
            }
        }
        return true;
    }

    public void replaceList(List<T> list) {
        // This either needs to be synchronized or switch to a local field for adapterHasUpdated.
        // Probably synchronized because a list should finish updating before being replaced again
        if (listIsEqualTo(list)) {
            return;
        }

        new Handler().post(() -> {
            startTransaction();
            applyAndAnimateRemovals(list);
            applyAndAnimateAdditions(list);
            applyAndAnimateMovedItems(list);
            stopTransaction();
            adapterHasUpdated = false;
        });
    }

    private void startTransaction() {
        if (transactionListener == null) {
            return;
        }

        transactionListener.startTransaction();
    }

    private void stopTransaction() {
        if (transactionListener == null) {
            return;
        }

        transactionListener.finishTransaction(adapterHasUpdated);
    }

    private void applyAndAnimateRemovals(List<T> newList) {
        for (int i = list.size() - 1; i >= 0; i--) {
            final T model = list.get(i);
            if (!newList.contains(model)) {
                removeItem(i);
                adapterHasUpdated = true;
            }
        }
    }

    private void applyAndAnimateAdditions(List<T> newList) {
        for (int i = 0, count = newList.size(); i < count; i++) {
            final T item = newList.get(i);
            if (!list.contains(item)) {
                addItem(i, item);
                adapterHasUpdated = true;
            }
        }
    }

    private void applyAndAnimateMovedItems(List<T> newList) {
        for (int toPosition = newList.size() - 1; toPosition >= 0; toPosition--) {
            final T item = newList.get(toPosition);
            final int fromPosition = list.indexOf(item);
            if (fromPosition >= 0 && fromPosition != toPosition) {
                moveItem(fromPosition, toPosition);
                adapterHasUpdated = true;
            }
        }
    }

    public void clearList() {
        removeItems(0, getItemCount() - 1);
    }

    public void removeItem(int position) {
        list.remove(position);
        notifyItemRemoved(position);
    }

    public void addItem(int position, T item) {
        list.add(position, item);
        notifyItemInserted(position);
    }

    public void moveItem(int fromPosition, int toPosition) {
        final T item = list.remove(fromPosition);
        list.add(toPosition, item);
        notifyItemMoved(fromPosition, toPosition);
    }

    public void registerTransactionListener(TransactionListener transactionListener) {
        this.transactionListener = transactionListener;
    }

    public void addItems(int initialPosition, List<T> items) {
        for (T item : items) {
            addItem(initialPosition, item);
            initialPosition++;
        }
    }

    public void removeItems(int fromPosition, int toPosition) {
        for (int i = toPosition; i >= fromPosition; i--) {
            removeItem(i);
        }
    }
}