This article learns how to use EventBus 3.0 together.
EventBus is used to publish/subscribe event bus, which simplifies communication between components, components and background threads in the application. The advantage is that the expenses are small, the code is more elegant, and the deed and the receiver are decoupled.

1. Three elements of EventBus

• Event: Event can be an object of any type.
• Subscriber: Event subscriber. The method of annotating by @Subscripe is the event processing method, and the parameter ThreadMode specifies the thread model (default Threadmode.posting), and it will be mentioned below the four thread models.
• Publisher: Incident publisher, you can send the event at any thread, directly call the eventbus.getdefault (). Post (Event) method. According to the type of the EVENT parameter, the function of subscribing to the EVENT will be automatically called.

2. The four ThreadMode of EventBus

• Posting (default)
  Publishing and receiving events are in the same thread.
  Try to avoid time -consuming operations in the event processing function, because it will block the transmission of events and may even cause Anr.
• MAIN:
  The handling of the event will be performed in the UI thread.
  Similarly, the event processing time should not be too long, otherwise it will cause anr.
• BACKGROUND
  If the issuance event is in the UI thread, the receiving event will run in the new thread.
  If the issue event is in the sub -thread, the receiving event is executed in the same thread.
  UI update operations are prohibited in this event processing function.
• ASYNC
  No matter which thread is released, the receiving event will be executed in the newly built sub -thread.
  UI update operations are prohibited in this incident processing function.

3. basic usage of EventBus

• Add dependency library

implementation 'org.greenrobot:eventbus:3.1.1'

• Get the EventBus object

EventBus.getDefault()

• Custom event class

public class MessageEvent {
    public int event;
    public String message;
    public Object object;

    public MessageEvent(int event) {
        this.event = event;
    }

    public MessageEvent(int event, String message) {
        this.event = event;
        this.message = message;
    }

    public MessageEvent(int event, String message, Object object) {
        this.event = event;
        this.message = message;
        this.object = object;
    }
}

• Find the timing of subscription, registration event

  EventBus.getDefault().register(subscriber); // Subscriber type is Object, that is, the category of subscribed

• Send event

EventBus.getDefault().post(messageEvent);

• Event handling method

@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void onEventTest(MessageEvent messageEvent) {
	int event = messageEvent.event;
	// Event processing ...
}

• Subscribe to cancel incident

  EventBus.getDefault().unregister(subscriber);

Fourth, code application

• Custom event class follows the MESSAGEEVENT class above
• Custom MyEventbus, integrate registration/cancellation events, event handling methods, etc.

public class MyEventBus {
    public static final String TAG = "MyEventBus";
    public static MyEventBus instance;
    public static final int EVENT_UPDATE = 1;
    public static MyEventBus getInstance() {
        if (instance == null) {
            synchronized(MyEventBus.class) {
                if (instance == null) {
                    instance = new MyEventBus();
                }
            }
        }
        return instance;
    }

	// Register event
    public void register() {
        EventBus.getDefault().register(this);
    }

	// Cancel the registration event
    public void unregister() {
        EventBus.getDefault().unregister(this);
    }

    /**
           * Event processing method, according to the specified ThreadMode, will be executed in the background thread, so UI operation cannot be performed
     */
    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onEventBackground(MessageEvent messageEvent) {
        int event = messageEvent.event;
        switch (event) {
            case EVENT_UPDATE:
            	...
                break;
        }
    }
}

• For example, in the oncreate () registration event of Activity, click the button to send an event, onDestroy () cancel the event

    @Override
    protected void onCreate() {
    	MyEventBus.getInstance().register(this);
    }
    
    public void clickPostEvent(View view) {
    	MessageEvent event = new MessageEvent(EmmEventBus.EVENT_UPDATE);
        EventBus.getDefault().post(event);
    }
    
  	@Override
    protected void onDestroy() {
        MyEventBus.getInstance().unregister(this);
    }

5. Eventbus 3.0 sticky event

In addition to the ordinary events mentioned above, EventBus also supports sending sticky events, namely: Send an event-> subscription event-> handling event.
There are only the following differences in the writing of sticky events:

// The processing method of viscosity event, increase the attribute sticky = true
@Subscribe(threadMode = ThreadMode.BACKGROUND，sticky = true)
public void onEventBackground(MessageEvent messageEvent) {
	...
}

// Send sticky event
EventBus.getDefault().postSticky(new MessageEvent(2));