Hi everyone!

I would like to know if we could change RVRendererAdapter and RVListRendererAdapter collection type to Collection<T> instead of AdapteeCollection<T>.

It causes me trouble in the following situation. I would like to update just one item from the list instead of performing a full diffUpdate. Since there is no set method in AdapteeCollection I can only do the following:

List<T> list = (List<T>) collection;
list.set(position, newElement);
notifyItemChanged(position);

The drawback of this approach is that it is performing a cast over collection assuming that the implementation inherits from List.

Another way of tackling this issue would be copying all elements into aList<T> and performing the set operation there. But that is even worse given the original collection is already a List<T> and we would be doing a useless copy.

Are there any arguments against using Collection instead of AdapteeCollection?

Changed RendererBuilder generics for supporting descendants classes to FIX #24.

E.g. In case when B, C extends A. This change allows to create RendererBuilder<A> And bind rendering C objects using Renderer<C> and B objects to render with Renderer<B>.

Also this change improves encapsulation.

Changed constructor to public RendererBuilder(Collection<? extends Renderer<? extends T>> prototypes) that allows to use descendants. e.g. When we have class A that extends B, we can use for creating RendererBuilder<B> collection that contains Renderer<A> and Renderer<B>. And bindings will configure what renderer should be used for what model class.

Added copy of collection to constructor for better encapsulation.

getPrototypes added Collections.unmodifiableList for better encapsulation.

public final void setPrototypes(Collection<? extends Renderer<? extends T>> prototypes) and RendererBuilder<T> withPrototypes(Collection<? extends Renderer<? extends T>> prototypes) changed to received descendants renderers.

Make AdapteeCollection<T> compatible with List<T> interface, so any class implementing a List could be used as an AdapteeCollection by simply implementing it. For example, ListAdapteeCollection<T> can be now implemented with less code.

Puedes subir algún ejemplo un poco más sencillo y directo?

Me está costando un poco implementar la librería en mi proyecto. Me he liado un poco con el ejemplo que tienes subido.

Sobre todo a la hora de iniciar el adaptador:

RendererAdapter adapter = new RendererAdapter(inflater,B, C);

En B que incluyo? y en C?

Gracias.

RVRendererAdapter addAll signature differs from the Collection one making it impossible to use it with collections of subtypes. The fix is as easy as changing the method signature from

public void addAll(Collection<T> elements)

to

public void addAll(Collection<? extends T> elements)

It will be backwards compatible which is always nice.

Hi @pedrovgs!

As indicated in Issue#44, I updated the dependencies and adapted the code to the corresponding API changes.

The only dependency which hasn't been updated to the latest version is ButterKnife. It was causing conflicts with androidX and it required minSdk Android N.

I hope it this is useful! Cheers.

This closes #44

After the latest Architecture Components release made by Google during December 2017 we've noticed they have released a new adapter named PagedListAdapter we should support. As the architecture component is a new module we should provide this as a new renderers module so we don't add the architecture components to the main artifact. More information can be found in this video

Creates DiffRVRendererAdapter that extends RVRendererAdapter but provides and interface in order to work in combination with the new DiffUtil that comes with the support library.

Also an example is provided.

In some occasions when it creates a AdapteeCollection for RVRendererAdapter needs a RecyclerView.Adapter.

• Problem example using package android.support.v7.util.SortedList:

public MyAdapteeCollectionConstructor(RecyclerView.Adapter ANY_ADAPTER) {

    this.messageList = new SortedList<Message>(Message.class, new SortedListAdapterCallback<Message>(ANY_ADAPTER) {
            @Override
            public int compare(Message o1, Message o2) {
                return o1.compareTo(o2);
            }

            @Override
            public boolean areContentsTheSame(Message oldItem, Message newItem) {
                return oldItem.equals(newItem);
            }

            @Override
            public boolean areItemsTheSame(Message item1, Message item2) {
                return item1.getId().equals(item2.getId());
            }
        });
}

RVRendererAdapter creation:

adapter = new RVRendererAdapter<Message>(new MessageRenderBuilder(), new MyAdapteeCollection(WHAT ADAPTER?));

• Solution with actual Renderers version for this example:

public MyAdapteeCollectionConstructor() {
    //init default messageList
}

...

 public void initCollection(RecyclerView.Adapter adapter) {
        messageList = new SortedList<Message>(Message.class, new SortedListAdapterCallback<Message>(adapter) {
            @Override
            public int compare(Message o1, Message o2) {
                return o1.compareTo(o2);
            }

            @Override
            public boolean areContentsTheSame(Message oldItem, Message newItem) {
                return oldItem.equals(newItem);
            }

            @Override
            public boolean areItemsTheSame(Message item1, Message item2) {
                return item1.getId().equals(item2.getId());
            }
        });
    }

RVRendererAdapter creation:

adapteeCollection = new MyAdapteeCollection();
adapter = new RVRendererAdapter<Message>(new MessageRenderBuilder(), adapteeCollection);
adapteeCollection.initCollection(adapter);

• Solution with for this example (better solution?):

public MyAdapteeCollectionConstructor(RecyclerView.Adapter ANY_ADAPTER) { ... }

RVRendererAdapter creation:

adapter = new RVRendererAdapter<Message>(new MessageRenderBuilder());
adapter.setCollection(new MyAdapteeCollection(adapter));

Hello,

I have started work on new sample, that binds different renderer classes to different model classes, was planing to make it on top of Video and VideoRenderer. But there are problems: VideoRenderer sets layout that will use in subclasses, Video model has too much fields.

What if I would make completely different example, not about videos?

Buenas Pedro, no consigo entender como implementar la gestion del click a un elemento de la lista sin hacer uso de inyeccion de dependencias..¿Tienes algun ejemplo? Gracias por la libreria, creo que me va a ahorrar años de dolores de cabeza xD

We are going to update all the project documentation and add a new module supporting Kotlin properly. We will make the library more idiomatic and kotlin friendly so our Android users can enjoy it 😃

As it turns out, Kotlin synthetic properties cache works by default on Activities, Fragments, and Views, but it does not do so for ViewHolder. They fixed this as of Kotlin 1.1.4 via LayoutContainer.

Consumers of this libraries have to make sure they make their Renderers implement LayoutContainer if they are using synthetic properties inside of them. If they do not, their ViewHolders are going to call findViewById() on every call to render() making their ViewHolders obsolete. It would be nice if the library itself did this maybe by adding a Kotlin specific artifact that implements this interface (implementation should be trivial). Thoughts?