RxObservableList.java

import android.databinding.ObservableArrayList;
import android.databinding.ObservableList;

import com.jakewharton.rxrelay.PublishRelay;

import java.util.List;

import rx.Observable;

/**
 * A cache of items held in memory, with modifications exposed via Observable.
 *
 * @author David Whitman on Apr 13, 2017.
 */
public class RxObservableList<T> {
    private ObservableList<T> items = new ObservableArrayList<T>();
    private PublishRelay<Event<T>> relay = PublishRelay.create();

    public RxObservableList() {
        items.addOnListChangedCallback(new ObservableList.OnListChangedCallback<ObservableList<T>>() {
            @Override
            public void onChanged(ObservableList<T> sender) {
                relay.call(new ChangedEvent<T>(sender));
            }

            @Override
            public void onItemRangeChanged(ObservableList<T> sender, int positionStart, int itemCount) {
                relay.call(new ItemRangeChangedEvent<T>(sender, positionStart, itemCount));
            }

            @Override
            public void onItemRangeInserted(ObservableList<T> sender, int positionStart, int itemCount) {
                relay.call(new ItemRangeInsertedEvent<T>(sender, positionStart, itemCount));
            }

            @Override
            public void onItemRangeMoved(ObservableList<T> sender, int fromPosition, int toPosition, int itemCount) {
                relay.call(new ItemRangeMovedEvent<T>(sender, fromPosition, toPosition, itemCount));
            }

            @Override
            public void onItemRangeRemoved(ObservableList<T> sender, int positionStart, int itemCount) {
                relay.call(new ItemRangeRemovedEvent<T>(sender, positionStart, itemCount));
            }
        });
    }

    public Observable<Event<T>> getObservable() {
        return relay;
    }

    public List<T> getItems() {
        return items;
    }

    public List<T> getObservableList() {
        return items;
    }

    // Event declarations

    public static abstract class Event<T> {
        private List<T> sender;

        public Event(List<T> sender) {
            this.sender = sender;
        }

        public List<T> getSender() {
            return sender;
        }
    }

    public static class ChangedEvent<T> extends Event<T> {
        public ChangedEvent(List<T> sender) {
            super(sender);
        }
    }

    public static class ItemRangeChangedEvent<T> extends Event<T> {
        private final int positionStart;
        private final int itemCount;

        public ItemRangeChangedEvent(List<T> sender, int positionStart, int itemCount) {
            super(sender);
            this.positionStart = positionStart;
            this.itemCount = itemCount;
        }

        public int getPositionStart() {
            return positionStart;
        }

        public int getItemCount() {
            return itemCount;
        }
    }

    public static class ItemRangeInsertedEvent<T> extends Event<T> {
        private final int positionStart;
        private final int itemCount;

        public ItemRangeInsertedEvent(List<T> sender, int positionStart, int itemCount) {
            super(sender);
            this.positionStart = positionStart;
            this.itemCount = itemCount;
        }

        public int getPositionStart() {
            return positionStart;
        }

        public int getItemCount() {
            return itemCount;
        }
    }

    public static class ItemRangeMovedEvent<T> extends Event<T> {
        private final int fromPosition;
        private final int toPosition;
        private final int itemCount;

        public ItemRangeMovedEvent(List<T> sender, int fromPosition, int toPosition, int itemCount) {
            super(sender);
            this.fromPosition = fromPosition;
            this.toPosition = toPosition;
            this.itemCount = itemCount;
        }

        public int getFromPosition() {
            return fromPosition;
        }

        public int getToPosition() {
            return toPosition;
        }

        public int getItemCount() {
            return itemCount;
        }
    }

    public static class ItemRangeRemovedEvent<T> extends Event<T> {
        private final int positionStart;
        private final int itemCount;


        public ItemRangeRemovedEvent(List<T> sender, int positionStart, int itemCount) {
            super(sender);
            this.positionStart = positionStart;
            this.itemCount = itemCount;
        }

        public int getPositionStart() {
            return positionStart;
        }

        public int getItemCount() {
            return itemCount;
        }
    }
}

RxObservableList.kt

import android.databinding.ObservableArrayList
import android.databinding.ObservableList

import com.jakewharton.rxrelay.PublishRelay

import rx.Observable

/**
 * A cache of items held in memory, with modifications exposed via Observable.

 * @author David Whitman on Apr 13, 2017.
 */
class RxObservableList<T> {
    private val items = ObservableArrayList<T>()
    private val relay = PublishRelay.create<Event<T>>()

    init {
        items.addOnListChangedCallback(object : ObservableList.OnListChangedCallback<ObservableList<T>>() {
            override fun onChanged(sender: ObservableList<T>) {
                relay.call(ChangedEvent(sender))
            }

            override fun onItemRangeChanged(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
                relay.call(ItemRangeChangedEvent(sender, positionStart, itemCount))
            }

            override fun onItemRangeInserted(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
                relay.call(ItemRangeInsertedEvent(sender, positionStart, itemCount))
            }

            override fun onItemRangeMoved(sender: ObservableList<T>, fromPosition: Int, toPosition: Int, itemCount: Int) {
                relay.call(ItemRangeMovedEvent(sender, fromPosition, toPosition, itemCount))
            }

            override fun onItemRangeRemoved(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
                relay.call(ItemRangeRemovedEvent(sender, positionStart, itemCount))
            }
        })
    }

    val observable: Observable<Event<T>>
        get() = relay

    fun getItems(): List<T> {
        return items
    }

    val observableList: List<T>
        get() = items

    // Event declarations

    abstract class Event<T>(val sender: List<T>)

    class ChangedEvent<T>(sender: List<T>) : Event<T>(sender)

    class ItemRangeChangedEvent<T>(sender: List<T>, val positionStart: Int, val itemCount: Int) : Event<T>(sender)

    class ItemRangeInsertedEvent<T>(sender: List<T>, val positionStart: Int, val itemCount: Int) : Event<T>(sender)

    class ItemRangeMovedEvent<T>(sender: List<T>, val fromPosition: Int, val toPosition: Int, val itemCount: Int) : Event<T>(sender)

    class ItemRangeRemovedEvent<T>(sender: List<T>, val positionStart: Int, val itemCount: Int) : Event<T>(sender)
}