Dica Rápida: Como Usar a Biblioteca EventBus

() translation by (you can also view the original English article)

Final product image — What You'll Be Creating

Construindo um aplicativo Android que tem várias componentes ativos que comunicam uns com os outros pode se tornar tedioso. Para economizar tempo, os desenvolvedores muitas vezes acabam com componentes fortemente acoplados em seus aplicativos. EventBus é uma biblioteca open-source popular que foi criado para resolver esse problema usando o padrão publisher/subscriber.

Usando a biblioteca EventBus, você pode passar mensagens de uma classe para uma ou mais classes em apenas algumas linhas de código. Além disso, todas as classes envolvidas são completamente desacopladas uma da outra, levando a um codigo que é menos complexo e mais fácil de manter e depurar.

Nesta dica rápida, você vai aprender como usar a biblioteca EventBus, através da construção de um aplicativo Android simples, que exibe o status de carregamento do dispositivo. Porque as mudanças no status do carregamento são eventos do sistema, o aplicativo vai ter uma Activity que precisa receber informações de um BroadcastReceiver - cenário perfeito para se usar um event bus.

Pré-requisitos

Certifique-se de que você tem o ADT Bundle Eclipse configurado. Você pode baixá-lo a partir do site Android Developer.

1. Criar Novo Projeto

Inicie o Eclipse e crie uma nova aplicação Android. Nomeie a aplicação com EventBusSample. Escolha um nome de pacote único e defina o Minimum Required SDK para Android 2.2 e o Target SDK para o Android 4.4.

Nós mesmos vamos criar a Activity, então desmarque Create Activity e clique em Finish.

Deselect Create Activity and click Finish

2. Edite o Manifest

Este aplicativo tem um BroadcastReceiver que responda às seguintes ações:

android.intent.action.ACTION_POWER_CONNECTED
android.intent.action.ACTION_POWER_DISCONNECTED

Nomeie o BroadcastReceiver para ChargingReceiver e declare-o no arquivo AndroidManifest.xml.

<receiver android:name=".ChargingReceiver">
    <intent-filter>
        <action android:name="android.intent.action.ACTION_POWER_CONNECTED" />
        <action android:name="android.intent.action.ACTION_POWER_DISCONNECTED" />
    </intent-filter>
</receiver>

O app tem uma Activity para exibir o status de carregamento. Nomeie a DisplayActivity e declará-lo como mostrado abaixo.

<activity android:name=".DisplayActivity">
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>            
</activity>

3. Adicione a Biblioteca EventBus

Baixe a versão mais recente da biblioteca EventBus como um JAR de Maven Central e adicione o JAR no diretório libs do seu projeto.

4. Crie a Classe `ChargingEvent`

Eventos de event bus são nada além de objetos que contêm a informação que precisa ser comunicado. Vamos atribuir ChargingEvent ao nome da classe que contém as informações passadas a partir do BroadcastReceiver à Activity. Esta é uma classe simples que tem apenas uma String para representar a informação. Ele também tem um construtor para definir o valor da string e um get para obter seu valor.

Crie um novo arquivo chamado ChargingEvent.java e adicione o seguinte código a ele:

package com.hathy.eventbussample;

public class ChargingEvent {
    private String data;
  
	public ChargingEvent(String data){			
		this.data = data;
	}
	
	public String getData(){
		return data;
	}
}

5. Crie uma Classe `BroadcastReceiver`

Criar uma nova classe chamada ChargingReceiver que estenda de BroadcastReceiver. Essa classe usa o event bus para publicar mensagens. Ele tem uma variável chamada de bus, que faz referência ao bus criado pela biblioteca EventBus. O bus é um singleton e você tem que usar o método getDefault para se referir a ele.

No método onReceive, nós criamos uma nova instância da classe ChargingEvent e adicionamos a nossa mensagem a ele. Aqui está uma mensagem de exemplo:

1	@14:23:20 this device started charging.

Para gerar esta mensagem, precisamos fazer o seguinte:

Use os métodos disponíveis na classe de Time para definir a tempo em que o evento ocorreu.
Concatene a string "este dispositivo começou a carregar | descarregar" com base na ação recebida. Se a ação for recebida Intent.ACTION_POWER_CONNECTED, o dispositivo está a carregando. Se for Intent.ACTION_POWER_DISCONNECTED, o dispositivo está a descarregar.

Uma vez que o objeto ChargingEvent tem a informação correta, é publicado no event bus, utilizando o método post. A implementação da classe ChargingReceiver agora deve ter esta aparência:

package com.hathy.eventbussample;

import de.greenrobot.event.EventBus;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.text.format.Time;

public class ChargingReceiver extends BroadcastReceiver {

    private EventBus bus = EventBus.getDefault(); 
	
	@Override
	public void onReceive(Context context, Intent intent) {
		ChargingEvent event = null;
		
		// Get current time
		Time now = new Time();
		now.setToNow();		
		String timeOfEvent = now.format("%H:%M:%S");
		
		String eventData = "@" + timeOfEvent + " this device started ";
		if(intent.getAction().equals(Intent.ACTION_POWER_CONNECTED)){
			event=new ChargingEvent(eventData+"charging.");
		} else if(intent.getAction().equals(Intent.ACTION_POWER_DISCONNECTED)){
			event=new ChargingEvent(eventData+"discharging.");
		}
		
		// Post the event
		bus.post(event);
	}

}

Como você pode ver, a publicação de mensagens para o event bus tem apenas uma única linha de código. Além disso, o editor não precisa saber nada sobre o assinante(s).

6. Criar a Classe `DisplayActivity`

Criar uma nova classe chamada DisplayActivity. Esta classe é responsável por exibir as mensagens dos eventos publicados no event bus.

Esta classe também tem uma variável que faz referência o event bus. Como a biblioteca EventBus segue o padrão singleton, a exemplo do event bus disponível para essa Activity, é o mesmo que a instância à disposição do BroadcastReceiver.

Para permitir que uma classe para se inscrever em eventos bus, o método de register é invocado. Em nossa Activity, podemos chamá-lo no método onCreate.

Da mesma forma, para parar de receber eventos, o método unregister é invocado. Nós chamamos este método no método onDestroy para se certificar de todos os recursos são liberados.

A Activity tem uma layout muito básico, contendo apenas um TextView que exibe as mensagens. Portanto, não há necessidade de criar um layout para ele. Nós simplesmente usamos TextView como view do conteúdo de Activity.

Neste ponto, a implementação da classe DisplayActivity deve ficar assim:

package com.hathy.eventbussample;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import de.greenrobot.event.EventBus;

public class DisplayActivity extends Activity {
    
	private EventBus bus = EventBus.getDefault();
	
	private TextView view;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {	
		super.onCreate(savedInstanceState);
		
		view = new TextView(this);

		view.setTextSize(20f);
		view.setPadding(20, 20, 20, 20);
		view.setText("Waiting for events...");
		
		setContentView(view);

		// Register as a subscriber
		bus.register(this);
	}	
	
	@Override
	protected void onDestroy() {
		// Unregister
		bus.unregister(this);
		super.onDestroy();
	}

}

Cada classe que pretende receber eventos do event bus deve conter um método onEvent. O nome deste método é importante, porque a biblioteca EventBus usa a API de Reflexão Java para acessar este método. Tem um único parâmetro que se refere ao evento. No nosso caso, o parâmetro vai ser do tipo ChargingEvent.

Tudo o que fazemos neste método é anexar a última mensagem recebida para o conteúdo do TextView. A implementação do método onEvent parece com isso:

1	public void onEvent(ChargingEvent event){
2	view.setText(view.getText() + "\n" + event.getData());
3	}

7. Execute e Teste

O aplicativo agora está pronto para ser testado. Compilar e executá-lo em um dispositivo físico Android. Uma vez que o aplicativo tenha terminado o lançamento, conectar e desconectar o cabo de alimentação de um par de vezes para ver a troca status de carregamento.

Conclusão

Neste tutorial, você aprendeu como usar a biblioteca EventBus, e quanto ela simplifica a comunicação entre classes. A biblioteca é otimizado para a plataforma Android e é muito leve. Isso significa que você pode usá-lo em seus projetos sem ter que se preocupar com o tamanho do seu app. Para saber mais sobre a biblioteca EventBus, visite o projeto no GitHub.

Seja o primeiro a saber sobre novas traduções–siga @tutsplus_pt no Twitter!