La diffusion est divisée en deux types différents: "Diffusions normales" et "Diffusions ordonnées". La diffusion ordinaire est complètement asynchrone et peut être reçue par tous les récepteurs de diffusion en même temps (logiquement). L'efficacité de la livraison des messages est relativement élevée, mais l'inconvénient est que le récepteur ne peut pas transmettre le résultat du traitement au récepteur suivant, et il ne peut pas être terminé. Propagation d'intention de diffusion; cependant, la diffusion ordonnée est basée sur la priorité déclarée par le récepteur (déclarée dans l'attribut android: priority de l'élément intent-filter, plus le nombre est grand, plus la priorité est élevée, la plage de valeurs: -1000 à 1000. C'est aussi possible Appelez le setPriority () de l'objet IntentFilter à définir), et le destinataire reçoit la diffusion à son tour. Par exemple, si le niveau de A est supérieur à celui de B et que le niveau de B est supérieur à C, la diffusion est d'abord transmise à A, puis à B et enfin à C. peut stocker des données dans la diffusion. Lorsque l'émission est envoyée à B, B peut obtenir les données stockées par A à partir de l'émission.
Context.sendBroadcast ()
Ce qui est envoyé est une émission ordinaire et tous les abonnés ont la possibilité de l'obtenir et de la traiter.
Context.sendOrderedBroadcast ()
L'envoi est une diffusion ordonnée. Le système exécutera les récepteurs un par un selon la priorité déclarée par le récepteur. Le récepteur précédent a le droit de mettre fin à la diffusion (BroadcastReceiver.abortBroadcast ()). Si l'émission est terminée par le récepteur précédent, ce dernier ne peut plus recevoir l'émission. Pour une diffusion ordonnée, le récepteur précédent peut stocker le résultat du traitement dans l'intention de diffusion, puis le transmettre au récepteur suivant.
Le récepteur de diffusion (BroadcastReceiver) est utilisé pour recevoir l'intention de diffusion, et l'envoi de l'intention de diffusion est réalisé en appelant Context.sendBroadcast () et Context.sendOrderedBroadcast (). Habituellement, une intention de diffusion peut être reçue par plusieurs récepteurs de diffusion abonnés à cette intention. Cette fonctionnalité est similaire aux récepteurs de messages de rubrique dans JMS. Pour implémenter une méthode de récepteur de diffusion, procédez comme suit:
La première étape: définir le récepteur de diffusion, hériter de BroadcastReceiver et réécrire la méthode onReceive ().
classe publique IncomingSMSReceiver extendBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
Étape 2: Abonnez-vous à la diffusion Intention d'intérêt, il existe deux méthodes d'abonnement:
Le premier type: utilisez le code pour vous abonner (abonnement dynamique)
Filtre IntentFilter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
Récepteur IncomingSMSReceiver = newIncomingSMSReceiver ();
registerReceiver (récepteur, filtre);
Le deuxième type: abonnez-vous à la nœud dans le fichier AndroidManifest.xml (abonnement statique)
Jetons un coup d'œil à la différence entre un abonnement de diffusion dynamique et un abonnement de diffusion statique:
La diffusion par abonnement statique est également appelée: diffusion résidente. Lorsque votre application est fermée, s'il y a un message de diffusion, le récepteur de diffusion que vous avez écrit peut également le recevoir. Sa méthode d'enregistrement est AndroidManifast dans votre application. .xml pour l'abonnement.
La diffusion dynamique par abonnement est également appelée: diffusion non résidente. Lorsque l'application se termine, la diffusion disparaîtra naturellement. Par exemple, vous vous abonnez à la diffusion dans onCreate ou onResume dans l'activité, et vous devez annuler l'abonnement à la diffusion dans onDestory ou onPause. Sinon, une exception sera signalée, de sorte que votre récepteur de diffusion sera un non-résident.
Il y a un autre détail ici qui concerne les deux méthodes d'abonnement. Lors de l'envoi de diffusions, vous devez faire attention aux points suivants: La méthode d'intention implicite est utilisée pour l'enregistrement dynamique, vous devez donc utiliser l'intention implicite d'envoyer lors de l'envoi de diffusions. , Sinon, le récepteur de diffusion ne pourra pas recevoir l'émission. Faites attention à ce point. Mais lors de l'abonnement statique, car il est abonné à AndroidMainfest.xml, il est possible d'utiliser Display Intent et implicit Intent lors de l'envoi de diffusions (bien sûr, ce n'est que pour les récepteurs de diffusion définis par nous-mêmes), donc juste au cas où, nous utilisons généralement implicite Intention d'envoyer une diffusion.
Regardons un exemple:
Jetez un œil à la structure du projet:
Jetez un œil à la diffusion de l'abonnement statique:
paquet com.broadcast.demo;
importer android.app.Activity;
importer android.content.Intent;
importer android.os.Bundle ;
importer android.view.View ;
importer android.view.View.OnClickListener;
importer android.widget.Button;
importer com.example.androidbroadcastdemo.R;
/ **
* Diffusion d'abonnement statique
* @auteur weijiang204321
*
*/
public class StaticRegisterBroadcastActivity étend l'activité {
@ Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Bouton btn = (Bouton) findViewById (R.id.btn);
À
btn.setOnClickListener (nouveau OnClickListener () {
@ Override
public void onClick (vue v) {
// Utilisez un moyen statique pour enregistrer la diffusion, vous pouvez utiliser l'intention d'affichage pour envoyer la diffusion
Diffusion d'intention = nouvelle intention ("com.broadcast.set.broadcast");
sendBroadcast (diffusion, nul);
}
À
});
}
À
}
Abonnez-vous à AndroidMainfest.xml:
<manifeste xmlns:android="http://schemas.android.com/apk/res/android"
package = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<utilise-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<demande
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<activité
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Ne vous inquiétez pas pour les autres contenus pour le moment, comme nous en reparlerons plus tard, ici nous nous concentrons uniquement sur l'enregistrement des diffusions statiques
Jetons un coup d'œil au récepteur de l'émission:
paquet com.broadcast.receiver;
importer android.content.BroadcastReceiver;
importer android.content.Context;
importer android.content.Intent;
importer android.util.Log ;
/ **
* Récepteur de diffusion
* @auteur weijiang204321
*
*/
public class UnSortBroadcastReceiver étend BroadcastReceiver {
@ Override
public void onReceive (Contexte contextuel, intention d'intention) {
Log.e ("Intent_Action:", intent.getAction () + "");
}
}
La logique de la méthode onReceive dans le récepteur de diffusion est très simple, qui consiste à imprimer le contenu de l'action.
Exécutez le programme, le résultat est très simple, voici pas l'image.
Jetons un coup d'œil aux abonnements dynamiques:
paquet com.broadcast.demo;
importer android.app.Activity;
importer android.content.Intent;
importer android.content.IntentFilter;
importer android.os.Bundle ;
importer android.view.View ;
importer android.view.View.OnClickListener;
importer android.widget.Button;
importer com.broadcast.receiver.UnSortBroadcastReceiver;
importer com.example.androidbroadcastdemo.R;
/ **
* Utilisez un moyen dynamique pour enregistrer la diffusion
* @auteur weijiang204321
*
*/
public class DynamicRegisterBroadcastActivity étend l'activité {
À
public static final String NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
récepteur UnSortBroadcastReceiver protégé;
À
@ Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Bouton btn0 = (Bouton) findViewById (R.id.btn);
btn0.setOnClickListener (nouveau OnClickListener () {
public void onClick (vue v) {
// Envoyer la diffusion
Intent it = new Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@ Override
protected void onResume () {
super.onResume ();
// S'inscrire à la diffusion
IntentFilter counterActionFilter = new IntentFilter (NEW_LIFEFORM_DETECTED);
récepteur = nouveau UnSortBroadcastReceiver ();
registerReceiver (récepteur, counterActionFilter);
}
@ Override
protected void onPause () {
super.onPause ();
// Annuler la diffusion
unregisterReceiver (récepteur);
}
}
Ici, nous nous abonnons à la diffusion dans onResume et nous nous désabonnons à la diffusion dans onPause.
Remplacez l'activité lancée par DynamicRegisterBroadcastActivity dans AndroidMainfest.xml. L'autre contenu n'a pas besoin d'être modifié. Exécutez le programme et imprimez le résultat est très simple, donc je ne verrai pas l'image ici.
Jetons un coup d'œil à la diffusion ordonnée et à la diffusion non ordonnée
Nous l'avons déjà mentionné au début, jetons un coup d'œil à la diffusion désordonnée:
Nous définissons d'abord deux récepteurs de diffusion:
Le premier récepteur de diffusion:
paquet com.broadcast.receiver;
importer android.content.BroadcastReceiver;
importer android.content.Context;
importer android.content.Intent;
importer android.util.Log ;
/ **
* Récepteur de diffusion A
* @auteur weijiang204321
*
*/
public class SortBroadcastReceiverA étend BroadcastReceiver {
@ Override
public void onReceive (Contexte contextuel, intention d'intention) {
Log.e ("Démo:", "récepteur de diffusion A");
}
}
Le deuxième récepteur de diffusion:
paquet com.broadcast.receiver;
importer android.content.BroadcastReceiver;
importer android.content.Context;
importer android.content.Intent;
importer android.util.Log ;
/ **
* Récepteur de diffusion B
* @auteur weijiang204321
*
*/
public class SortBroadcastReceiverB étend BroadcastReceiver {
@ Override
public void onReceive (Contexte contextuel, intention d'intention) {
Log.e ("Démo:", "Diffusion B");
}
À
À
}
Abonnez-vous pour diffuser dans AndroidMainfest.xml
résultat de l'opération:
Le résultat en cours d'exécution est un peu étrange. Pourquoi le récepteur B à l'avant et le récepteur A à l'arrière? La raison en est que lorsque nous nous abonnons à la diffusion dans AndroidMainfest.xml, nous définissons la valeur d'attribut android: priority dans le filtre d'intention. Plus la valeur est élevée, plus la priorité est élevée. , La priorité du récepteur B est 1000, la priorité du récepteur A est 999, donc B reçoit la diffusion en premier, puis A la reçoit, mais il n'y a pas de connexion entre le récepteur B et le récepteur A, et il ne peut y avoir aucune interaction Oui, car il s'agit d'une diffusion dans le désordre et asynchrone, nous pouvons faire une expérience en ajoutant du code à la méthode onReceiver en B:
abortBroadcast (); // Termine la transmission de cette émission
résultat de l'opération:
Nous pouvons voir l'erreur d'invite, c'est-à-dire qu'une diffusion non ordonnée n'est pas autorisée à mettre fin à la diffusion. En fait, la terminaison est inutile, car le récepteur A reçoit toujours l'émission.
Jetons un coup d'œil à la diffusion ordonnée, le code doit être modifié:
Le premier est lors de l'envoi d'une diffusion:
Diffusion d'intention = nouvelle intention ("com.broadcast.set.broadcast");
sendOrderedBroadcast (diffusion, null);
Ensuite, ajoutez une méthode pour terminer la diffusion dans le récepteur B:
abortBroadcast ();
L'autre code n'a pas besoin d'être modifié, le résultat de l'opération:
Il n'y a que le récepteur B, le récepteur A ne reçoit pas l'émission, car la diffusion se termine dans le récepteur B et les récepteurs suivants ne peuvent pas l'accepter.
Modifiez le code ci-dessous:
Destinataire B:
paquet com.broadcast.receiver;
importer android.content.BroadcastReceiver;
importer android.content.Context;
importer android.content.Intent;
importer android.os.Bundle ;
importer android.util.Log ;
/ **
* Récepteur de diffusion B
* @auteur weijiang204321
*
*/
public class SortBroadcastReceiverB étend BroadcastReceiver {
@ Override
public void onReceive (Contexte contextuel, intention d'intention) {
Log.e ("Démo:", "récepteur de diffusion B");
Bundle bundle = nouveau Bundle ();
bundle.putString ("next_receiver", "next broadcast receiver");
setResultExtras (ensemble);
}
À
}
Une fois que B reçoit l'émission, il stocke une valeur et la transmet au récepteur suivant.
Code du récepteur A:
paquet com.broadcast.receive
Notre autre produit:
