Alternative view listener injection

[zserge]

Currently, the easiest form of binding a view listener is to use Java 8 closures:

v(Button.class,
  onClick(v => doSomething()));

This is compact and clean, but it creates a new onClickListener object each time. Of course one can write listeners inside a Renderable class, but that becomes somewhat bloated:

View.OnClickListener onButtonClicked  = (v) => doSomething();
...
v(Button.class,
  onClick(onButtonClicked));

I'm looking for some lightweight approach to use Renderable methods instead, e.g:

public void onButtonClicked(View v) {
  doSomething();
}
...
v(Button.class,
  onClick(???)); // refer to onButtonClicked somehow

The first thing coming to my mind is and event bus. An event instance will be passed into a view node, then the real listener bound by Anvil will submit that event instance to the event bus and the Renderable (or any other class) would handle it.

public void onEvent(ButtonClicked e) {
  doSomething();
}
...
v(Button.class,
  onClick(new ButtonClicked()));

Event objects are lightweight, which is great. I just worry about a massive amount of various event classes for each listener for each view. Any ideas?

[zserge]

Using events emitted inside the view listeners will bring the Flux architecture to Android.
That will be uni-directional data flow, views will emit events (Actions in Flux), Stores will subscribe to those actions and will perform the business login. One the action is handled and store has changed its state - it will call render() method to update the views.

Flexible architecture, explicit update path, immutable data and all other benefits of Flux.

[meoyawn]

don't you want to separate flux approach from just the rendering/UI events handling?

I think spawning the event object is exactly the same as spawning the OnClickListener, GC-wise

[zserge]

@adelnizamutdinov Correct, Anvil core doesn't provide any of the UI listener bindings at all, but it allows binding in general. Then Attrs.java provide most common listener bindings like OnClickListener, which is good if you have lambdas or if you write in Kotlin, but in Java 6 it can be a pain. I was looking for some method to bind class methods easily in Java 6, because now one has either:

View.OnClickListener mListener = new View.OnClickListener() {
  public void onClick(View v) {
    // Code here
  }
};
v(SomeView.class, onClick(mListener)); // Good thing - zero garbage

or

v(SomeView.class, onClick(new View.OnClickListener() {
  public void onClick(View v) {
    // Code here
  }
});

I like neither.

I agree that events are no lighter than this simple click listener, but maybe some event factory could be used to not instantiate new objects, but reuse the existing ones (one per binding).

Anyway, to me code lightness is more important here than the execution speed or GC.

[zserge]

I decided to not include this kind of functionality.
Most modern developers use Java 8 or Kotlin, so they can use method pointers or lambdas. I did the benchmarks, lambdas are very cheap, compilers often optimize them to be singletons. So no need to add events as the first-class citizens to Anvil.

Of course one might want to write a library on top of Anvil if he find this useful.