Tutorial e exemplos do Android `BroadcastReceiver

Um BroadcastReceiver é um componente andróide responsável pela escuta de eventos ou intenções de transmissão em todo o sistema.

Em Android, a maioria dos eventos do sistema são transmitidos através de objetos 'Intent'. Para fazer isto, estes objetos Intent são enviados para os BroadcastReceiver utilizando os métodos Context.sendBroadcast().

Quando tal evento é transmitido, o BroadcastReceiver receberá o evento e reagirá criando uma notificação de barra de status ou executando uma determinada tarefa.

Um BroadcastReceiver é um componente andróide como Atividade e Serviço, portanto, na maioria das vezes, ele precisa ser registrado no arquivo de manifesto andróide.

Entretanto, ao contrário da Atividade, os BroadcastReceiver não têm nenhuma interface de usuário.

O BroadcastReceiver como uma classe é abstrato, portanto, normalmente tem um método chamado onReceive() que nós substituímos para fazer a tarefa que queremos que aconteça quando a tarefa é recebida.

A maioria dos eventos padrão do sistema são definidos como strings de ação e podem ser encontrados na documentação da API para a classe Intent.

Suponha por exemplo, se seu aplicativo precisar ser notificado sempre que o usuário conectar ou desconectar o carregador ao dispositivo, duas ações de transmissão definidas na classe Intent fazem isso:

AÇÃO_PODER_DISCONECTADO
1. ACTION_POWER_CONNECTED.

Aqui está um exemplo.

public class PhoneChargerConnectedListener extends BroadcastReceiver {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (Intent.ACTION_POWER_CONNECTED.equals(action)) {
            context.startService(
            new Intent(MyService.ACTION_POWER_CONNECTED));
        } else if (Intent.ACTION_POWER_DISCONNECTED.equals(action)) {
        context.startService(
        new Intent(MyService.ACTION_POWER_DISCONNECTED));
        }
    }
}

Neste método, a única coisa que você faz é chamar "Contexto.startService()para delegar o evento a um service` que realiza o trabalho real.

Como registrar o `BroadcastReceiver`?

Bem, podemos registrar o broadcastReceiver de duas maneiras.

1. Através do AndroidManifest.xml

O método padrão para implementar **BroadcastReceivers*** é declará-los no manifesto de andróides.
Por causa disso, é possível para o "BroadcastReceiver" notificar seu "serviço" mesmo que o usuário ainda não tenha iniciado sua aplicação.

Isto é especialmente útil para aplicações que devem começar em certos eventos do sistema sem interação do usuário.

<receiver android_name=".PhoneChargerConnectedListener">
    <intent-filter>
        <action android_name="android.intent.action.ACTION_POWER_CONNECTED"/>
        <action android_name="android.intent.action.ACTION_POWER_DISCONNECTED"/>
    </intent-filter>
</receiver>

Este método também é a maneira mais fácil.

Ao utilizar AndroidManifest.xml para registrar BroadcastReceiver, sua aplicação receberá as Broadcasts até que você desinstale a aplicação. Isto significa que você tem um pouco de controle ou o ciclo de vida do 'BroadcastReceiver', pois você não pode simplesmente registrá-lo e desregistrá-lo como desejar.

Para fazer isso, você verifica a próxima maneira de registrar os receptores de radiodifusão.

2. Programmaticamente

BroadcastReceeceivers também podem ser registrados programmaticamente dentro de [Atividades] (https://camposha.info/android/activity) e Serviços.

Algumas intenções de transmissão só podem ser registradas programmaticamente. Por outro lado, algumas só funcionam se você as declarar em seu manifesto.

Quando você registra um BroadcastReceiver programático, você também tem que lembrar-se de cancelar o registro no correspondente callback.

Aqui está um exemplo:

public class MyActivity extends AppCompatActivity {
    private PhoneChargerConnectedListener myPhoneChargerConnectedListener;
    @Override
    protected void onResume() {
        super.onResume();
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Intent.ACTION_POWER_CONNECTED);
        intentFilter.addAction(Intent.ACTION_POWER_DISCONNECTED);
        myPhoneChargerConnectedListener = new PhoneChargerConnectedListener();
        registerReceiver(myPhoneChargerConnectedListener, intentFilter);
    }
    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(myPhoneChargerConnectedListener);
    }
}

Neste caso, registramos o BroadcastReceiver programmaticamente utilizando o método registerReceiver() da classe Contexto. Ao utilizar este método, podemos controlar o ciclo de vida de nosso BroadcastReceiver através de registrando e não-registrando de acordo com nossas exigências.

Exemplo com o AlarmManager

Vejamos um exemplo simples de receptor de radiodifusão com gerenciador de alarme.

Teremos uma atividade e uma classe.

(a). MainActivity.java

Comece criando uma atividade em seu estúdio andróide.

Aqui temos nossa classe MainActivity. Esta classe será Derivada da AppCompatActivity que reside na biblioteca de suporte.

Teremos três métodos:

onCreate(),
1. "Inicializar Visões()`,
1. "Vai()`.

A interface de usuário desta atividade será inflada a partir do content_main.xml utilizando o método setContentView().

As visualizações que utilizamos são EditTexts e Buttons.
Nós os referenciamos a partir de nossa especificação de layout utilizando o método findViewById().

Inicializaremos e iniciaremos nosso alarme no método go().

package com.tutorials.hp.alarmmanagerstarter;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    Button startBtn;
    EditText timeTxt;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

         initializeViews();

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });

    }

    /*
    INITIALIZE VIEWS
     */
    private void initializeViews()
    {
        timeTxt= (EditText) findViewById(R.id.timeTxt);
        startBtn= (Button) findViewById(R.id.startBtn);

        startBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
               go();
            }
        });
    }

    /*
    INITIALIZE AND START OUR ALARM
     */
    private void go()
    {
        //GET TIME IN SECONDS AND INITIALIZE INTENT
        int time=Integer.parseInt(timeTxt.getText().toString());
        Intent i=new Intent(this,MyReceiver.class);

        //PASS CONTEXT,YOUR PRIVATE REQUEST CODE,INTENT OBJECT AND FLAG
        PendingIntent pi=PendingIntent.getBroadcast(this,0,i,0);

        //INITIALIZE ALARM MANAGER
        AlarmManager alarmManager= (AlarmManager) getSystemService(ALARM_SERVICE);

        //SET THE ALARM
        alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()+(time*1000),pi);
        Toast.makeText(MainActivity.this, "Alarm set in "+time+" seconds", Toast.LENGTH_SHORT).show();
    }

}

(b). MyReciever.java

Nossa classe MyReciever.
Deriva da classe android.content.BroadcastReceiver.
Métodos: onReceive().
Mostramos uma mensagem de brinde em nosso método "onReceive()" para simular o toque de alarme.

package com.tutorials.hp.alarmmanagerstarter;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.widget.Toast;

public class MyReceiver extends BroadcastReceiver {
    /*
    RING ALARM WHEN IN WHEN WE RECEIVE OUR BROADCAST
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        Toast.makeText(context, "Alarm Ringing...", Toast.LENGTH_SHORT).show();
    }
}

(c) activity_main.xml

Nosso principal arquivo de layout de atividade.
Deverá ser inflado para MainActivity.
Root tag é relativeLayout.
Contém um EditText e um botão.

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.tutorials.hp.alarmmanagerstarter.MainActivity"
    >

    <EditText
        android_id="@+id/timeTxt"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_layout_alignParentLeft="true"
        android_layout_alignParentTop="true"
        android_layout_marginTop="28dp"
        android_ems="10"
        android_hint="Number of seconds"
        android_inputType="numberDecimal" />

    <Button
        android_id="@+id/startBtn"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_layout_alignRight="@+id/timeTxt"
        android_layout_below="@+id/timeTxt"
        android_layout_marginRight="60dp"
        android_layout_marginTop="120dp"
        android_text="Start" />
</RelativeLayout>

(d). AndroidManifest.xml

Teremos que registrar nossa classe BroadcastReceiver em nosso manifesto andróide.

Aqui está meu manifesto na íntegra:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    package="com.tutorials.hp.alarmmanagerstarter">
    <application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity
            android_name=".MainActivity"
            android_label="@string/app_name"
            android_theme="@style/AppTheme.NoActionBar">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <receiver android_name="MyReceiver" >
        </receiver>
    </application>

</manifest>

Rápido `BroadcastReceiver` Exemplos

1. Ouça as mudanças de estado da rede com 'BroadcastReceiver'.

Primeiro precisamos criar uma classe java, e depois fazê-la derivar de android.content.BroadcastReceiver.

Como campos de exemplo, teremos um booleano isNetWorkConnected que nos dará uma indicação verdadeira ou falsa se a rede está conectada ou não.

Teremos também um objeto Contexto.

Fornecemos dois construtores, um que injetará em nossa classe o objeto 'Contexto'.
Em seguida, substituímos o método onReceive() da classe BroadcastReceiver. Normalmente, este método recebe dois objetos, um objeto 'Contexto' e o outro objeto 'Intento'.

Aqui inicializaremos um ConnectivityManager utilizando o método getSystemService() ,da classe Context.

Utilizando a instância ConnectivityManager, invocamos o método getActiveNetworkInfo() para receber informações de rede que temos em um objeto android.net.NetworkInfo.

Por fim, definimos o valor isConnected()isNetWorkConnected` boolean.

Então também temos o método isNetWorkAvailable(), que basicamente verificará por nós se a rede está disponível.

É apenas um método público que precisa que a instância desta classe seja invocada, como veremos dentro de pouco tempo.

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.widget.Toast;
import java.util.concurrent.CopyOnWriteArrayList;

public class NetWorkStateReceiver extends BroadcastReceiver {
    public boolean isNetWorkConnected;
    private Context mContext;

    public NetWorkStateReceiver() {
        super();
    }
    public NetWorkStateReceiver(Context context) {
        mContext = context;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager connectivityManager = (ConnectivityManager)
                context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();

        if (networkInfo != null && networkInfo.isConnected()) {
            isNetWorkConnected = true;
        } else {
            isNetWorkConnected = false;
            Toast.makeText(context, "No network Connection", Toast.LENGTH_SHORT).show();
        }

    }

    /**
     * Check if network is available
     * @return boolean value
     */
    public boolean isNetWorkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager)
                mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
        if (networkInfo != null) {
            return networkInfo.isConnected();
        }
        return false;
    }
}

Depois, em sua MainActivity ou onde quer que seja, você pode vir e começar por instanciar a classe acima:

    publi class MainActivity extends AppCompatActivity{
        NetWorkStateReceiver receiver;
        @Override
        public void onCreate(Bundle savedInstanceState){
            .....
           receiver = new NetWorkStateReceiver(this);
           if(receiver.isNetWorkAvailable())
           {
               //do something network is available
           }
        }
    }

Em você AndroidManifest.xml você deve atirar adicionar as permissões apropriadas, assim como registrar seu BroadcastReceiver:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    >

    <uses-permission android_name="android.permission.INTERNET" />
    <uses-permission android_name="android.permission.ACCESS_NETWORK_STATE" />
    <application>
        ....
        <receiver
            android_name=".broadcasts.NetWorkStateReceiver"
            android_enabled="true"
            android_exported="true" />
        ....
    </application>

2. Como criar um `BroadcastReceiver` personalizado

Aqui está uma classe BroadcastReciever abstrata personalizada. Obviamente, ela deriva do "BroadcastReceiver". Prosseguimos e redefinimos os métodos importantes nesta classe como os métodos registerReceiver(), unregisterReceiver() e sendBroadcast().


import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.support.v4.content.LocalBroadcastManager;

public abstract class LocalBroadcastCommunicator extends BroadcastReceiver {

    // The action name used to send and alsoe receive intents
    private static String sAction = null;

    private static <T> void registerReceiver(LocalBroadcastCommunicator receiver, Context context) {
        sAction = receiver.getClass().getName();
        LocalBroadcastManager.getInstance(context).registerReceiver(receiver, new IntentFilter(sAction));
    }

    private static <T> void unregisterReceiver(LocalBroadcastCommunicator receiver, Context context) {
        LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver);
    }

    public static void sendBroadcast(Context context, Intent intent) {
        if(sAction == null) {
            /* If sAction is null at this point, no receiver has been registered yet and there's no
             * point in sending a broadcast. */
            return;
        }

        intent.setAction(sAction);
        LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
    }

    public void registerReceiver(Context context) {
        registerReceiver(this, context);
    }

    public void unregisterReceiver(Context context) {
        unregisterReceiver(this, context);
    }
}

Exemplos completos

1. Como exibir notificação para Bateria Baixa utilizando `BroadcastReceiver'.

Estamos criando um gerenciador de bateria simples usando a classe BroadcasteReceiver. Mostraremos o nível da Bateria em um TextView e mostraremos o progresso na barra de progresso.

Aqui estão algumas das API's que você pode não saber que usamos:

**(a). BroadcastReceiver***.

Esta é a classe base do código que receberá as intenções enviadas por sendBroadcast().

**(b). IntentFilter***.

IntentFilter é uma descrição estruturada dos valores 'Intent' a serem correspondidos. Um IntentFilter pode se comparar com "ações", "categorias" e "dados" (seja através de seu tipo, esquema e/ou caminho) em um "Intent".

**(c). Gerenciador de bateria***.

Esta classe contém cordas e constantes utilizadas para os valores na ACTION_BATTERY_CHANGED`Intent.

**MainActivity.java***

Esta é a principal atividade.

package com.example.ankitkumar.broadcastreceiver_batterymanager;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    TextView batteryLevel;
    ProgressBar myProgressBar;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        batteryLevel = (TextView)findViewById(R.id.textView);
        myProgressBar = (ProgressBar)findViewById(R.id.progressBar);
        IntentFilter intentFilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
        registerReceiver(myBroadcastReceiver, intentFilter);

    }

    BroadcastReceiver myBroadcastReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            context.unregisterReceiver(this);
            int currentLevel = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
            int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
            int level = -1;
            if (currentLevel >= 0 && scale > 0) {
                level = (currentLevel * 100) / scale;
            }
            batteryLevel.setText("Battery Level remaining :"+  level +"%");
            myProgressBar.setProgress(level);
        }
    };
}

**activity_main.xml***

Este é o layout principal da `atividade'.
Aqui teremos um TextView para mostrar o nível da bateria e uma barra de progressão para mostrar a porcentagem da bateria.

<?xml version="1.0" encoding="UTF-8"?>

<RelativeLayout
        tools_context="com.example.ankitkumar.broadcastreceiver_batterymanager.MainActivity" android_paddingTop="@dimen/activity_vertical_margin" android_paddingRight="@dimen/activity_horizontal_margin" android_paddingLeft="@dimen/activity_horizontal_margin" android_paddingBottom="@dimen/activity_vertical_margin" android_layout_height="match_parent" android_layout_width="match_parent" android_id="@+id/activity_main"  >

<TextView
        android_layout_height="wrap_content" android_layout_width="wrap_content" android_id="@+id/textView" android_layout_centerHorizontal="true" android_layout_centerVertical="true" android_textSize="20sp" android_text="Hello World!"/>

<ProgressBar
        android_layout_height="20dp" android_layout_width="match_parent" android_id="@+id/progressBar" android_layout_alignParentRight="true" android_layout_alignParentEnd="true" android_layout_below="@+id/textView" android_layout_marginTop="25dp" android_max="100" style="?android:attr/progressBarStyleHorizontal"/>

</RelativeLayout>

**Download***

Não.	Localização	Link
1.	GitHub	Download
2.	GitHub	Browse	Browse	Browse
2.	GitHub	Criador Original: @AnkitKumar111	[GitHub	Criador Original: @AnkitKumar111

2. Utilize `BroadcastReceiver` para ouvir o InComing SMS e mostrá-lo

Nós escutamos esse SMS recebido e depois o lemos e o mostramos em uma mensagem de brinde.

**MainActivity.java***

Esta é a principal atividade.

package com.example.ankitkumar.msgreceive;

import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //checking wether the permission is already granted
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED) {

            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_SMS}, 1);

        }

    }

}

**IcomingSMS.java***

Nosso arquivo IncomingSMS.java. Aqui estão algumas das APIs que utilizamos:

**(a). SmsManager***.

Esta é uma classe definida no pacote 'android.telephony' que é responsável pela gestão de operações de SMS, tais como envio de dados, texto e mensagens pdu SMS.

**(b). SmsMessage***.

Isto representa uma mensagem de serviço de mensagens curtas.

package com.example.ankitkumar.msgreceive;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
import android.util.Log;
import android.widget.Toast;
import static android.telephony.SmsMessage.createFromPdu;

public class IncomingSms extends BroadcastReceiver {

    // Get the object of SmsManager
    final SmsManager sms = SmsManager.getDefault();

    @Override
    public void onReceive(Context context, Intent intent) {

        // Retrieves a map of extended data from the intent.
        final Bundle bundle = intent.getExtras();

        try {

            if (bundle != null) {

                final Object[] pdusObj = (Object[]) bundle.get("pdus");

                for (int i = 0; i < pdusObj.length; i++) {

                    SmsMessage currentMessage = createFromPdu((byte[]) pdusObj[i]);
                    String phoneNumber = currentMessage.getDisplayOriginatingAddress();

                    String senderNum = phoneNumber;
                    String message = currentMessage.getDisplayMessageBody();

                    Log.i("SmsReceiver", "senderNum: " + senderNum + "; message: " + message);

                    int duration = Toast.LENGTH_LONG;
                    final Toast toast = Toast.makeText(context, "senderNum: " + senderNum + ", message: " + message, duration);
                    toast.show();

                    //Countdown Timer for extending normal time of toast notification
                    new CountDownTimer(9000, 1000) {

                        public void onTick(long millisUntilFinished) {
                            toast.show();
                        }

                        public void onFinish() {
                            toast.show();
                        }

                    }.start();
                } // end for loop
            } // bundle is null

        } catch (Exception e) {
            Log.e("SmsReceiver", "Exception smsReceiver" + e);

        }
    }

}

**activity_main.xml***

Este é o layout principal da `atividade'.

<?xml version="1.0" encoding="UTF-8"?>

<RelativeLayout
        tools_context="com.example.ankitkumar.msgreceive.MainActivity" android_background="#f2f2f2" android_layout_height="match_parent" android_layout_width="match_parent"  >

<ImageView
        android_background="@drawable/ic_sms" android_layout_height="200sp" android_layout_width="200sp" android_contentDescription="@string/app_name" android_layout_centerInParent="true" android_alpha="0.4"/>

</RelativeLayout>

**Download***

Não.	Localização	Link
1.	GitHub	Download
2.	GitHub	Browse	[GitHub	Browse	[GitHub	Browse
2.	GitHub	Criador Original: @AnkitKumar111	[GitHub	Criador Original: @AnkitKumar111

Android `LocalBroadcastManager`

Android LocalBroadcastManager com IntentService Tutorial e Exemplo.

Este é um tutorial e exemplo de andróide LocalBroadcastManager. Queremos ver o que é "LocalBroadcastManager" e como utilizar com um "IntentService".

Tutorial em vídeo

Algumas pessoas sempre preferem os tutoriais em vídeo. Neste caso, aqui está a versão em vídeo deste tutorial.

O que você aprende neste Tutorial

Aqui estão alguns dos concpets que você aprenderá neste tutorial.

O que é um LocalBroadcastManager e sua definição de API.
Vantagens do LocalBroadcastManager.
Como utilizar o LocalBroadcastManager com o IntentService.

O que é 'LocalBroadcastManager'?

Bem, o 'LocalBroadcastManager' é uma classe de ajuda que nos permite registrar e enviar transmissões de intenções para objetos locais dentro de nosso processo.

Aqui está a definição da API:

public final class LocalBroadcastManager
extends Object

java.lang.Object
   ↳    android.support.v4.content.LocalBroadcastManager

Vantagens do `LocalBroadcastManager`

Aqui estão algumas das vantagens do 'LocalBroadcastManager' sobre o envio de transmissões globais com o método 'sendBroadcast(`Intent')':

Seus dados de aplicação são mantidos privados, pois esta classe funciona apenas com objetos de loal dentro de seu processo de aplicação.
É mais seguro devido ao fato de funcionar somente dentro de sua aplicação prcess.
Também é mais eficiente do que enviar uma transmissão global através do sistema.

(a). BroadcastSenderIntentService

Esta é nossa classe "IntentService". Derivaremos do método 'android.app.IntentService' e substituiremos o método 'onHandleIntent()'. Dentro deste método, simularemos uma tarefa pesada invocando o método "sleep()sleep()thread de nossa classe thread`.

package info.camposha.localbroadcastandintentservice;

import android.app.IntentService;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;

public class BroadcastSenderIntentService extends IntentService {

    public BroadcastSenderIntentService() {
        super("BroadcastSenderIntentService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        String message = getString(R.string.running);
        Intent broadcastIntent = new Intent();
        broadcastIntent.setAction(MainActivity.MESSAGE_SENT_ACTION);
        broadcastIntent.putExtra(MainActivity.MESSAGE_EXTRA, message);
        LocalBroadcastManager.getInstance(this).sendBroadcast(broadcastIntent);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        message = getString(R.string.finished);
        broadcastIntent = new Intent();
        broadcastIntent.setAction(MainActivity.MESSAGE_SENT_ACTION);
        broadcastIntent.putExtra(MainActivity.MESSAGE_EXTRA, message);
        LocalBroadcastManager.getInstance(this).sendBroadcast(broadcastIntent);
    }

}

(b). MainActivity.java

Aqui está nossa principal atividade. Começamos definindo várias constantes de cordas que serão úteis ao enviar e receber nossas intenções, uma vez que atuam como identificadores.

package info.camposha.localbroadcastandintentservice;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    public static final String MESSAGE_SENT_ACTION = "info.camposha.MESSAGE_RECEIVED_ACTION";
    public static final String MESSAGE_EXTRA = "info.camposha.MESSAGE_EXTRA";

    private static final String MESSAGE_FROM_SERVICE_KEY = "info.camposha.MESSAGE_FROM_SERVICE_KEY";

    private BroadcastReceiver receiver;
    private TextView serviceMessageView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        serviceMessageView = findViewById(R.id.service_message_textview);

        if (savedInstanceState != null) {
            serviceMessageView.setText(savedInstanceState.getString(MESSAGE_FROM_SERVICE_KEY));
        }else{
            serviceMessageView.setText("Null");
        }
    }

    @Override
    protected void onResume() {
        super.onResume();

        receiver = new BroadcastReceiver() {

            @Override
            public void onReceive(Context context, Intent intent) {
                Bundle bundle = intent.getExtras();
                String message = bundle.getString(MESSAGE_EXTRA);

                serviceMessageView.setText(message);
            }
        };

        LocalBroadcastManager.getInstance(this).registerReceiver(receiver, new IntentFilter(MESSAGE_SENT_ACTION));
    }

    @Override
    protected void onPause() {
        super.onPause();

        if (receiver != null) {
            LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver);
            receiver = null;
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString(MESSAGE_FROM_SERVICE_KEY, serviceMessageView.getText().toString());
    }

    public void onStartServiceClicked(View view) {
        startService(new Intent(this, BroadcastSenderIntentService.class));
    }

}

activity_main.xml

Aqui está o layout principal de nossa atividade. Temos aqui o textview e o botão.

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        tools_context=".MainActivity">

        <TextView
            android_id="@+id/headerLabel"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentTop="true"
            android_layout_centerHorizontal="true"
            android_fontFamily="casual"
            android_text="LocalBroadcastReceiver"
            android_textAllCaps="true"
            android_textSize="24sp"
            android_textStyle="bold" />

        <LinearLayout
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_centerHorizontal="true"
            android_layout_centerVertical="true"
            android_gravity="center"
            android_orientation="vertical" >

            <TextView
                android_id="@+id/textView1"
                android_layout_width="wrap_content"
                android_layout_height="wrap_content"
                android_text="@string/service_status"
                android_textSize="16dp" />

            <TextView
                android_id="@+id/service_message_textview"
                android_layout_width="wrap_content"
                android_layout_height="wrap_content"
                android_text="@string/not_running"
                android_textSize="16dp" />
        </LinearLayout>

        <Button
            android_id="@+id/button1"
            android_onClick="onStartServiceClicked"
            android_text="@string/start_service"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentBottom="true"
            android_layout_centerHorizontal="true"
            android_layout_marginBottom="12dp"
            android_fontFamily="serif-monospace" />

</RelativeLayout>

AndroidManifest.xml

Em nossa manifestação andróide você tem que se certificar de que registramos o serviço. Aqui está o meu:

<?xml version="1.0" encoding="utf-8"?>
<manifest
    package="info.camposha.localbroadcastandintentservice">

    <application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service
            android_name=".BroadcastSenderIntentService" />
    </application>

</manifest>

Kotlin `LocalBroadcastManager` Exemplo

Um exemplo de kotlin AndroidX localbroadcastmanager com "IntentService" e "BroadcastReceiver".

Veja o tutorial em vídeo aqui:

Passo 1: Adicionar Dependências

Adicione AndroiX localbroadcastmanager como uma dependência em seu arquivo de graduação:

    implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'

Passo 2: Layout do projeto

Desenhe um layout com um textvew e um botão:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="center"
    android:orientation="vertical">

    <TextView
        android:id="@+id/dateText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Initial value"
        android:textSize="20dp"
        android:textStyle="bold"/>

    <Button
        android:id="@+id/startButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text="Start Service"/>

</LinearLayout>

Passo 3: Criar `IntentService'.

Criamos uma classe de serviço intentservice e depois substituímos o método onHandleIntent:

package info.camposha.ms_localbroadcastmanager

import android.app.IntentService
import android.content.Intent
import android.util.Log
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import java.util.*

//IntentService is a ntentService is a base class for Services that handle asynchronous
// requests (expressed as Intents) on demand.
class MyIntentService : IntentService("MyIntentService") {
    override fun onHandleIntent(arg0: Intent?) {
        val intent = Intent(CUSTOM_ACTION)
        //get date to send
        intent.putExtra("DATE", Date().toString())
        Log.d(MyIntentService::class.java.simpleName, "sending broadcast")

        // send local broadcast
        //LocalBroadcastManager is a Helper to register for and send broadcasts of Intents
        // to local objects within your process.
        LocalBroadcastManager.getInstance(this).sendBroadcast(intent)
    }

    companion object {
        const val CUSTOM_ACTION = "YOUR_CUSTOM_ACTION"
    }
}

Etapa 4: Criar a MainActivity

Cretamos nosso lançador atividade:

package info.camposha.ms_localbroadcastmanager

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import kotlinx.android.synthetic.main.activity_main.*

//Our main activity
class MainActivity : AppCompatActivity(), View.OnClickListener {
    //override onCreate
    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        startButton.setOnClickListener(this)
    }

    //when activity is paused
    override fun onPause() {
        super.onPause()
        // unregister local broadcast
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver)
    }

    //when activity is resumed
    override fun onResume() {
        super.onResume()

        // register local broadcast
        val filter = IntentFilter(MyIntentService.CUSTOM_ACTION)
        LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, filter)
    }

    /**
    Create a BroadcastReceiver

     * BroadcastReceiver is a Base class for code that will receive intents sent by sendBroadcast().
     * Broadcast receiver to receive the data
     */
    private val mReceiver: BroadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val date = intent.getStringExtra("DATE")
            dateText.text = date
        }
    }

    //when user clicks the start button, start our intent service
    override fun onClick(view: View) {
        if (view.id == R.id.startButton) {
            // start intent service
            val intent = Intent(this, MyIntentService::class.java)
            startService(intent)
        }
    }
}

Passo 5: Registro de Componentes

Registrar dois componentes no arquivo de manifext andróide:

MainActivity
"Serviço interno".

 <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".MyIntentService"/>

Passo 6: Correr

Run Project e você terá o seguinte:

Código de download

Código para download aqui.

Categorized in:

Componentes Portuguese

Tutorial e exemplos do Android `BroadcastReceiver

Como registrar o `BroadcastReceiver`?

1. Através do AndroidManifest.xml

2. Programmaticamente

Exemplo com o AlarmManager

(a). MainActivity.java

(b). MyReciever.java

(c) activity_main.xml

(d). AndroidManifest.xml

Rápido `BroadcastReceiver` Exemplos

1. Ouça as mudanças de estado da rede com 'BroadcastReceiver'.

2. Como criar um `BroadcastReceiver` personalizado

Exemplos completos

1. Como exibir notificação para Bateria Baixa utilizando `BroadcastReceiver'.

2. Utilize `BroadcastReceiver` para ouvir o InComing SMS e mostrá-lo

Android `LocalBroadcastManager`

Tutorial em vídeo

O que você aprende neste Tutorial

O que é 'LocalBroadcastManager'?

Vantagens do `LocalBroadcastManager`

(a). BroadcastSenderIntentService

(b). MainActivity.java

activity_main.xml

AndroidManifest.xml

Kotlin `LocalBroadcastManager` Exemplo

Passo 1: Adicionar Dependências

Passo 2: Layout do projeto

Passo 3: Criar `IntentService'.

Etapa 4: Criar a MainActivity

Passo 5: Registro de Componentes

Passo 6: Correr

Código de download

Oclemy

Other Stories

Tutorial e exemplos do Android WebView

Press ESC to close

Or check our Popular Categories...

Como registrar o BroadcastReceiver?

1. Através do AndroidManifest.xml

2. Programmaticamente

Exemplo com o AlarmManager

(a). MainActivity.java

(b). MyReciever.java

(c) activity_main.xml

(d). AndroidManifest.xml

Rápido BroadcastReceiver Exemplos

1. Ouça as mudanças de estado da rede com 'BroadcastReceiver'.

2. Como criar um BroadcastReceiver personalizado

Exemplos completos

1. Como exibir notificação para Bateria Baixa utilizando `BroadcastReceiver'.

2. Utilize BroadcastReceiver para ouvir o InComing SMS e mostrá-lo

Android LocalBroadcastManager

Tutorial em vídeo

O que você aprende neste Tutorial

O que é 'LocalBroadcastManager'?

Vantagens do LocalBroadcastManager

(a). BroadcastSenderIntentService

(b). MainActivity.java

activity_main.xml

AndroidManifest.xml

Kotlin LocalBroadcastManager Exemplo

Passo 1: Adicionar Dependências

Passo 2: Layout do projeto

Passo 3: Criar `IntentService'.

Etapa 4: Criar a MainActivity

Passo 5: Registro de Componentes

Passo 6: Correr

Código de download

Oclemy

Related Articles

Exemplos de conta Android e gerente de contas

Kotlin Android Nested RecyclerView

Exemplo de Kotlin Android StateFlow

Kotlin Android Text To Speech e Speech To Text Example

Other Stories

Tutorial e exemplos do Android WebView

Como registrar o `BroadcastReceiver`?

Rápido `BroadcastReceiver` Exemplos

2. Como criar um `BroadcastReceiver` personalizado

2. Utilize `BroadcastReceiver` para ouvir o InComing SMS e mostrá-lo

Android `LocalBroadcastManager`

Vantagens do `LocalBroadcastManager`

Kotlin `LocalBroadcastManager` Exemplo