A emisión divídese en dous tipos diferentes: "Emisións normais" e "Emisións ordenadas". A transmisión ordinaria é completamente asíncrona e pode ser recibida por todos os receptores de transmisión ao mesmo tempo (loxicamente). A eficiencia da entrega de mensaxes é relativamente alta, pero a desvantaxe é que o receptor non pode pasar o resultado do procesamento ao seguinte receptor e non pode rematar. Propagación de intención de transmisión; con todo, a emisión ordenada baséase na prioridade declarada polo receptor (declarada no androide: atributo de prioridade do elemento de filtro de intención, canto maior sexa o número, maior será a prioridade, o rango de valores: -1000 a 1000. Tamén é posible Chama ao setPriority () do obxecto IntentFilter para establecer) e o destinatario recibe a transmisión á súa vez. Por exemplo, se o nivel de A é superior ao de B e o nivel de B é superior a C, entón a transmisión transmítese primeiro a A, logo a B e finalmente a C. Despois de que A reciba a emisión, pode almacenar datos na transmisión. Cando a transmisión se envía a B, B pode obter os datos almacenados por A da transmisión.
Context.sendBroadcast ()
O que se envía é unha emisión ordinaria e todos os subscritores teñen a oportunidade de obtela e procesala.
Context.sendOrderedBroadcast ()
O envío é unha emisión ordenada. O sistema executará os receptores un a un segundo a prioridade declarada polo receptor. O receptor anterior ten dereito a finalizar a transmisión (BroadcastReceiver.abortBroadcast ()). Se o receptor finaliza a transmisión, este último xa non pode recibir a transmisión. Para a emisión ordenada, o receptor anterior pode almacenar o resultado do procesamento na intención de transmisión e despois pasalo ao seguinte receptor.
O receptor de transmisión (BroadcastReceiver) úsase para recibir Intent de transmisión e o envío de Intent de difusión realízase chamando a Context.sendBroadcast () e Context.sendOrderedBroadcast (). Normalmente unha intención de transmisión pode ser recibida por varios receptores de transmisión subscritos a esta intención. Esta característica é similar aos receptores de mensaxes de tema en JMS. Para implementar un método de receptor de transmisión é o seguinte:
O primeiro paso: definir o receptor de transmisión, herdar BroadcastReceiver e reescribir o método onReceive ().
clase pública IncomingSMSReceiver extendsBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
Paso 2: subscríbete á transmisión Intención de interese, hai dous métodos de subscrición:
O primeiro tipo: usar código para subscribirse (subscrición dinámica)
Filtro IntentFilter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver receiver = newIncomingSMSReceiver ();
registerReceiver (receptor, filtro);
O segundo tipo: subscríbete no nodo no ficheiro AndroidManifest.xml (subscrición estática)
Vexamos a diferenza entre a subscrición de transmisión dinámica e a subscrición de transmisión estática:
A transmisión estática de subscrición tamén se chama: emisión residente. Cando se pecha a aplicación, se hai unha mensaxe de difusión, tamén o pode recibir o receptor de transmisión que escribiu. O seu método de rexistro é AndroidManifast na túa aplicación. .xml para a subscrición.
A transmisión dinámica de subscrición tamén se chama: transmisión non residente. Cando finalice a aplicación, a transmisión desaparecerá naturalmente. Por exemplo, estás subscrito á emisión en onCreate ou enResume na actividade e debes cancelar a subscrición de transmisión en onDestory ou onPause. En caso contrario, informarase dunha excepción, polo que o receptor de transmisión será un non residente.
Aquí hai un detalle máis que son os dous métodos de subscrición. Ao enviar emisións, debes prestar atención a: O método de intención implícita úsase para o rexistro dinámico, polo que debes usar a intención implícita para enviar cando envíes emisións. Se non, o receptor de transmisión non poderá recibir a transmisión. Preste atención a este punto. Pero cando se subscribe estáticamente, porque está subscrito en AndroidMainfest.xml, é posible usar Intent de visualización e Intent implícito cando se envían transmisións (por suposto, só para receptores de transmisión definidos por nós mesmos), polo que por se acaso, usamos implícito Intención de enviar a transmisión.
Vexamos un exemplo:
Bota unha ollada á estrutura do proxecto:
Bota unha ollada á transmisión estática de subscrición:
paquete 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.exemplo.androidbroadcastdemo.R;
/ **
* Emisión de subscrición estática
* @autor weijiang204321
*
*/
clase pública StaticRegisterBroadcastActivity estende Actividade {
@Anular
void protexido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Botón btn = (Botón) findViewById (R.id.btn);
Para
btn.setOnClickListener (novo OnClickListener () {
@Anular
public void onClick (Ver v) {
// Utilice un xeito estático para rexistrar a transmisión; pode utilizar a intención de visualización para enviar a transmisión
Intent broadcast = new Intent ("com.broadcast.set.broadcast");
sendBroadcast (emisión, nula);
}
Para
});
}
Para
}
Rexístrate en AndroidMainfest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<uses-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<aplicación
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<actividade
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Non te preocupes polo outro contido por agora, como falaremos máis adiante, aquí só nos centramos no rexistro de emisións estáticas
Vexamos o receptor da emisión:
paquete com.broadcast.receiver;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de transmisión
* @autor weijiang204321
*
*/
clase pública UnSortBroadcastReceiver estende BroadcastReceiver {
@Anular
baleiro público enRecibir (contexto de contexto, intención de intención) {
Log.e ("Intent_Action:", intent.getAction () + "");
}
}
A lóxica do método onReceive no receptor de transmisión é moi sinxela, que consiste en imprimir o contido da acción.
Executa o programa, o resultado é moi sinxelo, aquí non está a foto.
Vexamos as subscricións dinámicas:
paquete 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.exemplo.androidbroadcastdemo.R;
/ **
* Utiliza un xeito dinámico para rexistrar a transmisión
* @autor weijiang204321
*
*/
clase pública DynamicRegisterBroadcastActivity estende Actividade {
Para
cadea final estática pública NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
receptor UnSortBroadcastReceiver protexido;
Para
@Anular
void protexido onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Botón btn0 = (Botón) findViewById (R.id.btn);
btn0.setOnClickListener (novo OnClickListener () {
public void onClick (Ver v) {
// Enviar transmisión
Intent it = novo Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@Anular
baleiro protexido enResume () {
super.onResume ();
// Rexistrarse para a emisión
IntentFilter counterActionFilter = novo IntentFilter (NEW_LIFEFORM_DETECTED);
receptor = new UnSortBroadcastReceiver ();
registerReceiver (receptor, counterActionFilter);
}
@Anular
baleiro protexido onPause () {
super.onPause ();
// Cancelar emisión
unregisterReceiver (receptor);
}
}
Aquí estamos subscritos á emisión en onResume e cancelando a subscrición á emisión en onPause.
Cambia a actividade lanzada a DynamicRegisterBroadcastActivity en AndroidMainfest.xml. Non é necesario modificar o outro contido. Executa o programa e imprime o resultado é moi sinxelo, así que non vou ver a foto aquí.
Vexamos a emisión ordenada e a non ordenada
Xa o mencionamos ao principio, botemos unha ollada á transmisión desordenada:
Primeiro definimos dous receptores de transmisión:
O primeiro receptor de transmisión:
paquete com.broadcast.receiver;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de transmisión A
* @autor weijiang204321
*
*/
clase pública SortBroadcastReceiverA amplía BroadcastReceiver {
@Anular
baleiro público enRecibir (contexto de contexto, intención de intención) {
Log.e ("Demo:", "receptor de transmisión A");
}
}
O segundo receptor de transmisión:
paquete com.broadcast.receiver;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.util.Log;
/ **
* Receptor de transmisión B
* @autor weijiang204321
*
*/
clase pública SortBroadcastReceiverB amplía BroadcastReceiver {
@Anular
baleiro público enRecibir (contexto de contexto, intención de intención) {
Log.e ("Demostración:", "Emisión B");
}
Para
Para
}
Subscríbete para emitir en AndroidMainfest.xml
resultado da operación:
O resultado executado é un pouco raro. Por que está o receptor B na parte dianteira e o receptor A na parte traseira? A razón é que cando nos subscribimos á transmisión en AndroidMainfest.xml, configuramos o valor do atributo android: priority no filtro de intencións. Canto maior sexa o valor, maior será a prioridade. , A prioridade do receptor B é 1000, a prioridade do receptor A é 999, polo que B recibe primeiro a emisión e logo A recibe, pero non hai conexión entre o receptor B e o receptor A e non pode haber interacción. Si, porque esta é unha transmisión fóra de orde e asíncrona, podemos facer un experimento engadindo código ao método onReceiver en B:
abortBroadcast (); // Finaliza a transmisión desta transmisión
resultado da operación:
Podemos ver o erro inmediato, é dicir, non se permite que a emisión sen orde finalice a emisión. De feito, a terminación non serve para nada porque o receptor A aínda recibe a transmisión.
Vexamos a emisión ordenada, cómpre modificar o código:
O primeiro é cando se envía unha transmisión:
Intent broadcast = new Intent ("com.broadcast.set.broadcast");
sendOrderedBroadcast (emisión, nula);
A continuación, engada un método para finalizar a transmisión no receptor B:
abortBroadcast ();
Non é necesario modificar o outro código, o resultado da operación:
Só hai receptor B, o receptor A non recibe a transmisión, porque a transmisión remata no receptor B e os receptores posteriores non poden aceptala.
Modifique o código seguinte:
Destinatario B:
paquete com.broadcast.receiver;
importar android.content.BroadcastReceiver;
importar android.content.Context;
importar android.content.Intent;
importar android.os.Bundle;
importar android.util.Log;
/ **
* Receptor de transmisión B
* @autor weijiang204321
*
*/
clase pública SortBroadcastReceiverB amplía BroadcastReceiver {
@Anular
baleiro público enRecibir (contexto de contexto, intención de intención) {
Log.e ("Demo:", "receptor de transmisión B");
Bundle bundle = novo Bundle ();
bundle.putString ("seguinte_receptor", "seguinte receptor de transmisión");
setResultExtras (paquete);
}
Para
}
Despois de que B reciba a transmisión, almacena algo de valor e pásao ao seguinte receptor.
Código do receptor A:
paquete com.broadcast.receive
Noso outro produto:
