Após aprendermos sobre Activities, Content Providers e Services, resta um dos principais componentes de Android para estudarmos: os Broadcast Receivers.

Os Broadcast Receivers são componentes responsáveis por receber e tratar eventos (ou broadcasts) provenientes do sistema ou de outras aplicações.

Por exemplo, estes são alguns broadcasts do sistema que podem ser tratados por qualquer aplicação:

● android.intent.action.ACTION_BOOT_COMPLETED: indica que o telefone acabou de ser ligado
● android.intent.action.ACTION_POWER_CONNECTED: indica que o carregador foi conectado
● android.intent.action.ACTION_BATTERY_LOW: indica que o nível de bateria está baixo.

Tipos de Broadcast

Existem dois tipos principais de broadcasts:

– Ordered broadcast: nesse tipo de broadcast os receivers são invocados respeitando-se a prioridade que é definida ao registrá-los. Usando esta técnica também é possível abortar o broadcast após tratá-lo em sua aplicação.

– Normal broadcast: ao contrário do ordered broadcast, os broadcasts “normais” não respeitam a prioridade dos receivers e não podem ser abortados. Porém, sua performance é bastante superior.

Interface

Os Broadcast Receivers não possuem interface com usuário. Porém, eles podem lançar uma notificação para alertar o usuário que algum evento ocorreu ou invocar outros componentes como activities, services, etc.

Ciclo de vida

O ciclo de vida de um Broadcast Receiver é bastante simples: Quando o broadcast a ser capturado ocorre, o método onReceive() é chamado. Após isso, o broadcast receiver é retirado da memória.

É importante ressaltar que o método onReceive() é executado na main thread, então não devem ser executadas operações demoradas. Para estas, a melhor solução é lançar um Service, como veremos em nosso exemplo.

Implementação de um Broadcast Receiver

Nos capítulos anteriores implementamos um Service de sincronização que está sendo iniciado pela MainActivity. Imagine que agora o Serviço será executado uma vez por dia, à meia noite. Para isso, iremos criar uma nova classe, dentro do package android.helloworld.sync chamada SyncerBroadcastReceiver, com a seguinte implementação:

package android.helloworld.sync;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

public class SyncerBroadcastReceiver extends BroadcastReceiver{

    @Override
    public void onReceive(Context context, Intent intent) {
    	ConnectivityManager cm =
    	        (ConnectivityManager)context.getSystemService(
    	        		Context.CONNECTIVITY_SERVICE);
    	NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
    	
    	boolean isConnected = (activeNetwork != null) && activeNetwork.isConnected();
        if (isConnected) {
        	Intent i = new Intent(context, QuickNotesSyncService.class);
        	context.startService(i);
        }
    }
}

Com o broadcast receiver implementado, é necessário registrá-lo para ser executado. Isso pode ser feito de duas maneiras: através de uma entrada no manifest ou “programaticamente”, ou seja, através da chamada de uma função. No nosso caso, vamos registrá-lo para ser executado quando o dispositivo mudar seu estado de conectividade, da seguinte forma:

IntentFilter filter = new IntentFilter();
filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");

SyncerBroadcastReceiver receiver = new SyncerBroadcastReceiver();
registerReceiver(receiver, filter);

Assim, a AsyncTask responsável por inserir as notas, na nossa classe MainActivity, fica assim:

	private class AddNoteTask extends AsyncTask<String, Void, Uri> {
		@Override
		protected Uri doInBackground(String... string) {
			ContentValues values = new ContentValues();
			values.put(QuickNotesProvider.Notes.TEXT, string[0]);

			// Gravando a flag SYNCED com o valor 0, significando que 
			// a nota ainda não foi enviada ao servidor
			values.put(QuickNotesProvider.Notes.SYNCED, "0");

			Uri inserted = getContentResolver().insert(
					QuickNotesProvider.Notes.CONTENT_URI, values);

			ConnectivityManager cm =
					(ConnectivityManager)getSystemService(
							Context.CONNECTIVITY_SERVICE);
			NetworkInfo activeNetwork = cm.getActiveNetworkInfo();

			boolean isConnected = (activeNetwork != null) && activeNetwork.isConnected();

			// Iremos executar o serviço de sincronização apenas se houver conectividade com rede.
			// Caso contrário, iremos registrar o SyncerBroadcastReceiver para ser executado
			// assim que houver uma mudança no estado de conectividade.
			if (isConnected) {
				Intent i = new Intent(MainActivity.this, QuickNotesSyncService.class);
				startService(i); 
			} else {
				IntentFilter filter = new IntentFilter();
				filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");

				SyncerBroadcastReceiver receiver = new SyncerBroadcastReceiver();
				registerReceiver(receiver, filter);
			}

			return inserted;
		}

		@Override
		protected void onPostExecute(Uri result) {
			// Após a inserção da nota, vamos mostrar um Toast ao usuário
			Toast toast = Toast.makeText(MainActivity.this, 
					"Nota inserida com sucesso!", 
					Toast.LENGTH_SHORT);
			toast.show();
		}
	}

Por fim, é preciso declarar o SyncerBroadcastReceiver no Manifest da nossa aplicação, dentro da tag <application />

    <application
        android:icon="@drawable/icon"
        android:label="QuickNotes" >
  
        ...

        <receiver android:name="android.helloworld.sync.SyncerBroadcastReceiver" />
    </application>

Com isso, terminamos a implementação deste simples, mas importante componente.