A transmissão é dividida em dois tipos diferentes: "Transmissões normais" e "Transmissões ordenadas". A transmissão comum é totalmente assíncrona e pode ser recebida por todos os receptores de transmissão ao mesmo tempo (logicamente). A eficiência da entrega da mensagem é relativamente alta, mas a desvantagem é que o receptor não pode passar o resultado do processamento para o próximo receptor e ele não pode ser encerrado. Propagação de intenção de difusão; no entanto, a transmissão ordenada é baseada na prioridade declarada pelo receptor (declarada no atributo android: priority do elemento intent-filter, quanto maior o número, maior a prioridade, o intervalo de valores: -1000 a 1000. Também é possível Chame setPriority () do objeto IntentFilter para definir) e o destinatário receberá a transmissão por sua vez. Por exemplo, se o nível de A for mais alto do que o de B e o nível de B for mais alto do que C, a transmissão é primeiro transmitida para A, depois para B e, finalmente, para C. Depois que A obtém a transmissão, pode armazenar dados na transmissão. Quando a transmissão é enviada para B, B pode obter os dados armazenados por A a partir da transmissão.
Context.sendBroadcast ()
O que é enviado é uma transmissão comum e todos os assinantes têm a oportunidade de obtê-la e processá-la.
Context.sendOrderedBroadcast ()
O envio é uma transmissão ordenada. O sistema executará os receptores um a um de acordo com a prioridade declarada pelo receptor. O receptor anterior tem o direito de encerrar a transmissão (BroadcastReceiver.abortBroadcast ()). Se a transmissão for encerrada pelo receptor anterior, o último O receptor não poderá mais obter a transmissão. Para transmissão ordenada, o receptor anterior pode armazenar o resultado do processamento no Intent de transmissão e, em seguida, passá-lo para o próximo receptor.
O receptor de transmissão (BroadcastReceiver) é usado para receber Intent de transmissão, e o envio de Intent de transmissão é realizado chamando Context.sendBroadcast () e Context.sendOrderedBroadcast (). Normalmente, um Intent de transmissão pode ser recebido por vários receptores de transmissão inscritos para este Intent. Este recurso é semelhante aos receptores de mensagens de tópico no JMS. Para implementar um método de receptor de transmissão é o seguinte:
A primeira etapa: definir o receptor de transmissão, herdar BroadcastReceiver e reescrever o método onReceive ().
classe pública IncomingSMSReceiver estendeBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
Etapa 2: inscreva-se na intenção de transmissão da transmissão, existem dois métodos de inscrição:
O primeiro tipo: use o código para se inscrever (assinatura dinâmica)
Filtro IntentFilter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
Receptor IncomingSMSReceiver = newIncomingSMSReceiver ();
registerReceiver (receptor, filtro);
O segundo tipo: Inscreva-se no nó no arquivo AndroidManifest.xml (assinatura estática)
Vamos dar uma olhada na diferença entre assinatura de transmissão dinâmica e assinatura de transmissão estática:
A transmissão por assinatura estática também é chamada de transmissão residente. Quando seu aplicativo é fechado, se houver uma mensagem de broadcast, o receptor de broadcast que você escreveu também pode recebê-la. Seu método de registro é AndroidManifast em seu aplicativo. .xml para assinatura.
A transmissão por assinatura dinâmica também é chamada de transmissão não residente. Quando o aplicativo terminar, a transmissão irá desaparecer naturalmente. Por exemplo, você assina a transmissão em onCreate ou onResume na atividade e deve cancelar a assinatura de transmissão em onDestory ou onPause. Caso contrário, uma exceção será relatada, portanto, seu receptor de transmissão será um não residente.
Há mais um detalhe aqui que são os dois métodos de assinatura. Ao enviar broadcasts, você precisa prestar atenção a: O método de intenção implícita é usado para registro dinâmico, portanto, você precisa usar a intenção implícita para enviar ao enviar broadcasts. , Caso contrário, o receptor da transmissão não será capaz de receber a transmissão. Preste atenção a este ponto. Mas ao se inscrever estaticamente, porque é inscrito em AndroidMainfest.xml, é possível usar o intent de exibição e o intent implícito ao enviar transmissões (claro que isso é apenas para receptores de transmissão definidos por nós), então, apenas no caso, geralmente usamos implícito Intenção de enviar transmissão.
Vejamos um exemplo:
Dê uma olhada na estrutura do projeto:
Dê uma olhada na transmissão de assinatura estática:
pacote com.broadcast.demo;
importar android.app.Activity;
importar android.content.Intent;
importar android.os.Bundle;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.widget.Button;
importar com.example.androidbroadcastdemo.R;
/ **
* Transmissão de assinatura estática
* @autor weijiang204321
*
*/
public class StaticRegisterBroadcastActivity estende Activity {
@ Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Botão btn = (Botão) findViewById (R.id.btn);
Para
btn.setOnClickListener (new OnClickListener () {
@ Override
public void onClick (Ver v) {
// Use uma forma estática para registrar a transmissão, você pode usar a intenção de exibição para enviar a transmissão
Transmissão de intenção = nova intenção ("com.broadcast.set.broadcast");
sendBroadcast (broadcast, null);
}
Para
});
}
Para
}
Inscreva-se em AndroidMainfest.xml:
<manifesto xmlns:android="http://schemas.android.com/apk/res/android"
package = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<usa-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<aplicativo
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<atividade
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Não se preocupe com o outro conteúdo por enquanto, como falaremos mais tarde, aqui nos concentramos apenas no registro de transmissões estáticas
Vamos dar uma olhada no receptor da transmissão:
pacote com.broadcast.receptor;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de radiodifusão
* @autor weijiang204321
*
*/
public class UnSortBroadcastReceiver estende BroadcastReceiver {
@ Override
public void onReceive (Context context, Intent intent) {
Log.e ("Intent_Action:", intent.getAction () + "");
}
}
A lógica do método onReceive no broadcast receiver é muito simples, que consiste em imprimir o conteúdo da Action.
Execute o programa, o resultado é muito simples, aqui não é a imagem.
Vamos dar uma olhada nas assinaturas dinâmicas:
pacote com.broadcast.demo;
importar android.app.Activity;
importar android.content.Intent;
importar android.content.IntentFilter;
importar android.os.Bundle;
importar android.view.View;
importar android.view.View.OnClickListener;
importar android.widget.Button;
importar com.broadcast.receiver.UnSortBroadcastReceiver;
importar com.example.androidbroadcastdemo.R;
/ **
* Use uma maneira dinâmica de registrar a transmissão
* @autor weijiang204321
*
*/
public class DynamicRegisterBroadcastActivity estende Activity {
Para
public static final String NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
receptor UnSortBroadcastReceiver protegido;
Para
@ Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Botão btn0 = (Botão) findViewById (R.id.btn);
btn0.setOnClickListener (new OnClickListener () {
public void onClick (Ver v) {
// Enviar transmissão
Intent it = novo Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@ Override
protected void onResume () {
super.onResume ();
// Registre-se para transmissão
IntentFilter counterActionFilter = new IntentFilter (NEW_LIFEFORM_DETECTED);
receptor = novo UnSortBroadcastReceiver ();
registerReceiver (receptor, counterActionFilter);
}
@ Override
protected void onPause () {
super.onPause ();
// Cancelar transmissão
unregisterReceiver (receptor);
}
}
Aqui, estamos assinando uma transmissão em onResume e cancelando a assinatura em onPause.
Altere a Activity lançada para DynamicRegisterBroadcastActivity em AndroidMainfest.xml. O outro conteúdo não precisa ser modificado. Rodar o programa e imprimir o resultado é muito simples, então não vou ver a foto aqui.
Vamos dar uma olhada na transmissão ordenada e na transmissão não-ordenada
Já mencionamos isso no início, vamos dar uma olhada na transmissão desordenada:
Primeiro, definimos dois receptores de transmissão:
O primeiro receptor de transmissão:
pacote com.broadcast.receptor;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de transmissão A
* @autor weijiang204321
*
*/
public class SortBroadcastReceiverA extends BroadcastReceiver {
@ Override
public void onReceive (Context context, Intent intent) {
Log.e ("Demo:", "broadcast receiver A");
}
}
O segundo receptor de transmissão:
pacote com.broadcast.receptor;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de transmissão B
* @autor weijiang204321
*
*/
public class SortBroadcastReceiverB extends BroadcastReceiver {
@ Override
public void onReceive (Context context, Intent intent) {
Log.e ("Demonstração:", "Transmissão B");
}
Para
Para
}
Inscreva-se para transmitir em AndroidMainfest.xml
resultado da operação:
O resultado da corrida é um pouco estranho. Por que o receptor B está na frente e o receptor A atrás? O motivo é que, quando assinamos a transmissão em AndroidMainfest.xml, definimos o valor do atributo android: priority no intent-filter. Quanto maior for o valor, maior será a prioridade. , A prioridade do receptor B é 1000, a prioridade do receptor A é 999, então B recebe a transmissão primeiro e, em seguida, A recebe, mas não há conexão entre o receptor B e o receptor A e não pode haver interação Sim, como esta é uma transmissão fora de ordem e assíncrona, podemos fazer uma experiência adicionando código ao método onReceiver em B:
abortBroadcast (); // Encerrar a transmissão desta transmissão
resultado da operação:
Podemos ver o erro de prompt, ou seja, a transmissão não ordenada não tem permissão para encerrar a transmissão. Na verdade, a terminação é inútil, porque o receptor A ainda recebe a transmissão.
Vamos dar uma olhada na transmissão ordenada, o código precisa ser modificado:
A primeira é ao enviar uma transmissão:
Transmissão de intenção = nova intenção ("com.broadcast.set.broadcast");
sendOrderedBroadcast (broadcast, null);
Em seguida, adicione um método para encerrar a transmissão no receptor B:
abortBroadcast ();
O outro código não precisa ser modificado, o resultado da operação:
Existe apenas o receptor B, o receptor A não recebe a transmissão, porque a transmissão é encerrada no receptor B e os receptores subsequentes não podem aceitá-la.
Modifique o código abaixo:
Destinatário B:
pacote com.broadcast.receptor;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.os.Bundle;
importar android.util.Log;
/ **
* Receptor de transmissão B
* @autor weijiang204321
*
*/
public class SortBroadcastReceiverB extends BroadcastReceiver {
@ Override
public void onReceive (Context context, Intent intent) {
Log.e ("Demo:", "broadcast receiver B");
Bundle bundle = novo Bundle ();
bundle.putString ("next_receiver", "próximo receptor de transmissão");
setResultExtras (pacote);
}
Para
}
Depois que B recebe a transmissão, ele armazena algum valor e o passa para o próximo receptor.
Código do receptor A:
pacote com.broadcast.receive
Nosso outro produto:
