EventBus e gestione degli eventi

Nel contesto EventBus un evento è definito da un semplice POJO, ad esempio:

public class ActivityEvent {
  public String messagggio;
  public Date dataCreazione;
}

Un componente, Activity o Service che sia, per emettere un evento di tipo ActivityEvent deve utilizzare l'istanza del bus per effettuare il post di un evento passandogli come parametri un'istanza del tipo di evento che vuole lanciare.

EventBus.getDefault().post(new ActivityEvent());

Un componente, per mettersi in ascolto dell'evento rappresentato dalla classe ActivityEvent dovrà esporre un metodo annotato con l'annotazione @Subscribe

@Subscribe
public void onEvent(ActivityEvent event){
   ..
}

Ci possono essere diversi sottoscrittori o subscriber per un particolare tipo di evento, come ci possono essere diversi emettitori per lo stesso
evento. EventBus consente di specificare su quale thread far rimanere i
vari subscriber. Tutto ciò è possibile grazie all'attributo threadMode di @Subscribe.

I possibili valori che tale attributo può assumere sono:

Valore	Descrizione
BACKGROUND	Consente di rimanere in ascolto su un thread in background, se l'evento viene scatenato dal main-thread. Nel caso in cui l'evento è generato da un thread diverso dal main thread, allora verrà utilizzato lo stesso thread.
ASYNC	Il subscriber rimarrà in ascolto sempre su un thread in background, a prescindere dal thread che genera l'evento.
MAIN e MAIN_ORDERED	Con questi valori il subscriber verrà eseguito nel main thread. I due valori differiscono per il fatto che MAIN_ORDERED consente di accodare gli eventi evitando che il thread venga bloccato.
POSTING	I subscriber verranno eseguiti nello stesso thread dell'emettitore dell'evento.

EventBus: setup

Per configurare EventBus su gradle è sufficiente definire nel file build.gradle del progetto le
dipendenze del processore di annotazione con la sua configurazione (vedi annotationProcessorOptions).

android {
    ..
    defaulConfig {
        ..
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [eventBusIndex: "it.html.android.libraries.myapplication6.EventBusIndex"]
            }
        }
    }
    ..
}
dependencies {
    annotationProcessor 'eventbus-annotation-processor:3.1.1'
    implementation 'org.greenrobot:eventbus:3.1.1'
    ..
}

Oltre al processore di annotazione e alla libreria in sé, nel file gradle è necessario definire il nome della classe
che verrà generata e nel corso
dell'applicazione verrà utilizzata come registro degli eventi e dei subscriber. Nel caso riportato la classe indice
sarà it.html.android.libraries.myapplication6.EventBusIndex.

Questa classe indice deve essere registrata su EventBus prima di qualunque altra operazione sul bus. Per questo motivo, questa opearazione viene svolta nell'application,
all'avvio dell'app:

public class EsempioApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ..
        // gestore eventi
        EventBus.builder().addIndex(new EventBusIndex()).build();
        ..
    }
}

EventBus: registrare componenti sul bus di eventi

Un componente activity, service o fragment, per potersi registrare per ricevere la notifica degli eventi, si
deve registrare sul bus quando viene creato e, per evitare spreco di risorse, quando viene distrutto deve
de-registrarsi.

I vari componenti hanno diversi lifecycle, ma sostanzialmente hanno tutti un metodo eseguito quando viene creato (o
attivato) e uno quando viene distrutto (o deattivato).

Nel caso di activity:

@Override
protected void onResume() {
    EventBus.getDefault().register(this);
    super.onResume();
}
@Override
protected void onPause() {
    EventBus.getDefault().unregister(this);
    super.onPause();
}

Mentre nel caso di service:

@Override
public void onCreate() {
    super.onCreate();
    EventBus.getDefault().register(this);
}
@Override
public void onDestroy() {
    EventBus.getDefault().unregister(this);
    super.onDestroy();
}