La trasmissione è divisa in due diversi tipi: "Trasmissioni normali" e "Trasmissioni ordinate". La trasmissione ordinaria è completamente asincrona e può essere ricevuta da tutti i ricevitori di trasmissione contemporaneamente (logicamente). L'efficienza della consegna dei messaggi è relativamente alta, ma lo svantaggio è che il destinatario non può trasmettere il risultato dell'elaborazione al destinatario successivo e non può essere terminato. Propagazione dell'intento di trasmissione; tuttavia, la trasmissione ordinata si basa sulla priorità dichiarata dal destinatario (dichiarata nell'attributo android: priority dell'elemento intent-filter, maggiore è il numero, maggiore è la priorità, l'intervallo di valori: da -1000 a 1000. È anche possibile Chiama setPriority () dell'oggetto IntentFilter da impostare) e il destinatario riceve la trasmissione a sua volta. Ad esempio, se il livello di A è superiore a quello di B e il livello di B è superiore a C, la trasmissione viene prima trasmessa ad A, quindi a B e infine a C.Dopo che A riceve la trasmissione, può memorizzare i dati nella trasmissione. Quando la trasmissione viene inviata a B, B può ottenere i dati memorizzati da A dalla trasmissione.
Context.sendBroadcast ()
Ciò che viene inviato è una trasmissione normale e tutti gli abbonati hanno l'opportunità di ottenerlo ed elaborarlo.
Context.sendOrderedBroadcast ()
L'invio è una trasmissione ordinata. Il sistema eseguirà i ricevitori uno ad uno secondo la priorità dichiarata dal ricevitore. Il destinatario precedente ha il diritto di terminare la trasmissione (BroadcastReceiver.abortBroadcast ()). Se la trasmissione viene interrotta dal ricevitore precedente, quest'ultimo Il ricevitore non può più ricevere la trasmissione. Per la trasmissione ordinata, il ricevitore precedente può memorizzare il risultato dell'elaborazione nell'intento della trasmissione e quindi passarlo al ricevitore successivo.
Il ricevitore di trasmissione (BroadcastReceiver) viene utilizzato per ricevere l'Intento di trasmissione e l'invio di Intento di trasmissione viene realizzato chiamando Context.sendBroadcast () e Context.sendOrderedBroadcast (). Di solito un Intento di trasmissione può essere ricevuto da più ricevitori di trasmissione iscritti a questo Intento. Questa funzione è simile ai destinatari dei messaggi di argomento in JMS. Per implementare un metodo di ricezione di trasmissione è il seguente:
Il primo passo: definire il ricevitore di trasmissione, ereditare BroadcastReceiver e riscrivere il metodo onReceive ().
public class IncomingSMSReceiver extendBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
Passaggio 2: iscriviti all'intento di interesse della trasmissione, sono disponibili due metodi di iscrizione:
Il primo tipo: usa il codice per iscriverti (sottoscrizione dinamica)
Filtro IntentFilter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
Ricevitore IncomingSMSReceiver = newIncomingSMSReceiver ();
registerReceiver (ricevitore, filtro);
Il secondo tipo: iscriviti in nodo nel file AndroidManifest.xml (sottoscrizione statica)
Diamo un'occhiata alla differenza tra abbonamento a trasmissione dinamica e abbonamento a trasmissione statica:
La trasmissione statica in abbonamento è anche chiamata: trasmissione residente. Quando l'applicazione è chiusa, se è presente un messaggio di trasmissione, anche il destinatario della trasmissione che hai scritto può riceverlo. Il suo metodo di registrazione è AndroidManifast nella tua applicazione. .xml per la sottoscrizione.
La trasmissione dinamica in abbonamento è anche chiamata: trasmissione non residente. Quando l'applicazione termina, la trasmissione scomparirà naturalmente. Ad esempio, ti iscrivi alla trasmissione in onCreate o onResume nell'attività e devi annullare l'abbonamento alla trasmissione in onDestory o onPause. In caso contrario, verrà segnalata un'eccezione, quindi il destinatario della trasmissione sarà un non residente.
C'è un altro dettaglio qui che sono i due metodi di sottoscrizione. Quando si inviano trasmissioni, è necessario prestare attenzione a: Il metodo dell'intento implicito viene utilizzato per la registrazione dinamica, quindi è necessario utilizzare l'intento implicito per inviare quando si inviano trasmissioni. , In caso contrario, il ricevitore della trasmissione non sarà in grado di ricevere la trasmissione. Presta attenzione a questo punto. Ma quando ci si iscrive in modo statico, poiché è iscritto in AndroidMainfest.xml, è possibile utilizzare il display Intent e implicit Intent durante l'invio di trasmissioni (ovviamente questo è solo per i ricevitori di broadcast definiti da noi stessi), quindi per ogni evenienza, generalmente usiamo implicit Intenzione di inviare la trasmissione.
Diamo un'occhiata a un esempio:
Dai un'occhiata alla struttura del progetto:
Dai un'occhiata alla trasmissione in abbonamento statico:
pacchetto com.broadcast.demo;
importare Android.app.Activity;
importare Android.content.Intent;
importa android.os.Bundle;
importare android.view.View;
importare android.view.View.OnClickListener;
importa android.widget.Button;
importa com.example.androidbroadcastdemo.R;
/ **
* Trasmissione in abbonamento statico
* @autore weijiang204321
*
*/
public class StaticRegisterBroadcastActivity estende Activity {
@Oltrepassare
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Button btn = (Button) findViewById (R.id.btn);
A
btn.setOnClickListener (new OnClickListener () {
@Oltrepassare
public void onClick (View v) {
// Usa un modo statico per registrare la trasmissione, puoi usare l'intento di visualizzazione per inviare la trasmissione
Trasmissione intenzione = nuova intenzione ("com.broadcast.set.broadcast");
sendBroadcast (broadcast, null);
}
A
});
}
A
}
Iscriviti in AndroidMainfest.xml:
<xmlns manifesto: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" />
<applicazione
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<attività
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Non preoccuparti per gli altri contenuti per ora, di cui parleremo più avanti, qui ci concentriamo solo sulla registrazione delle trasmissioni statiche
Diamo un'occhiata al destinatario della trasmissione:
pacchetto com.broadcast.receiver;
importare android.content.BroadcastReceiver;
importare Android.content.Context;
importare Android.content.Intent;
importare android.util.Log;
/ **
* Ricevitore di trasmissione
* @autore weijiang204321
*
*/
public class UnSortBroadcastReceiver estende BroadcastReceiver {
@Oltrepassare
public void onReceive (Context context, Intent intent) {
Log.e ("Intent_Action:", intent.getAction () + "");
}
}
La logica del metodo onReceive nel ricevitore di trasmissione è molto semplice, ovvero stampare il contenuto dell'azione.
Esegui il programma, il risultato è molto semplice, qui non è l'immagine.
Diamo un'occhiata agli abbonamenti dinamici:
pacchetto com.broadcast.demo;
importare Android.app.Activity;
importare Android.content.Intent;
importa Android.content.IntentFilter;
importa android.os.Bundle;
importare android.view.View;
importare android.view.View.OnClickListener;
importa android.widget.Button;
importa com.broadcast.receiver.UnSortBroadcastReceiver;
importa com.example.androidbroadcastdemo.R;
/ **
* Utilizzare il modo dinamico per registrare la trasmissione
* @autore weijiang204321
*
*/
public class DynamicRegisterBroadcastActivity estende Activity {
A
stringa finale pubblica statica NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
ricevitore UnSortBroadcastReceiver protetto;
A
@Oltrepassare
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Button btn0 = (Button) findViewById (R.id.btn);
btn0.setOnClickListener (new OnClickListener () {
public void onClick (View v) {
// Invia trasmissione
Intent it = new Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@Oltrepassare
protected void onResume () {
super.onResume ();
// Registrati per la trasmissione
IntentFilter counterActionFilter = new IntentFilter (NEW_LIFEFORM_DETECTED);
ricevitore = nuovo UnSortBroadcastReceiver ();
registerReceiver (receiver, counterActionFilter);
}
@Oltrepassare
protected void onPause () {
super.onPause ();
// Annulla trasmissione
unregisterReceiver (ricevitore);
}
}
Qui ci stiamo iscrivendo alla trasmissione in onResume e annullando l'iscrizione alla trasmissione in onPause.
Modificare l'attività avviata in DynamicRegisterBroadcastActivity in AndroidMainfest.xml. L'altro contenuto non deve essere modificato. Eseguire il programma e stampare il risultato è molto semplice, quindi non vedrò l'immagine qui.
Diamo un'occhiata alle trasmissioni ordinate e alle trasmissioni non ordinate
Ne abbiamo già parlato all'inizio, diamo un'occhiata alle trasmissioni disordinate:
Per prima cosa definiamo due ricevitori di trasmissione:
Il primo ricevitore di trasmissione:
pacchetto com.broadcast.receiver;
importare android.content.BroadcastReceiver;
importare Android.content.Context;
importare Android.content.Intent;
importare android.util.Log;
/ **
* Ricevitore di trasmissione A
* @autore weijiang204321
*
*/
public class SortBroadcastReceiverA estende BroadcastReceiver {
@Oltrepassare
public void onReceive (Context context, Intent intent) {
Log.e ("Demo:", "ricevitore di trasmissione A");
}
}
Il secondo ricevitore di trasmissione:
pacchetto com.broadcast.receiver;
importare android.content.BroadcastReceiver;
importare Android.content.Context;
importare Android.content.Intent;
importare android.util.Log;
/ **
* Ricevitore di trasmissione B
* @autore weijiang204321
*
*/
la classe pubblica SortBroadcastReceiverB estende BroadcastReceiver {
@Oltrepassare
public void onReceive (Context context, Intent intent) {
Log.e ("Demo:", "Broadcast B");
}
A
A
}
Iscriviti per trasmettere in AndroidMainfest.xml
risultato dell'operazione:
Il risultato della corsa è un po 'strano. Perché il ricevitore B è davanti e il ricevitore A dietro? Il motivo è che quando ci iscriviamo alla trasmissione in AndroidMainfest.xml, impostiamo il valore dell'attributo android: priority nell'intent-filter. Maggiore è il valore, maggiore è la priorità. , La priorità del ricevitore B è 1000, la priorità del ricevitore A è 999, quindi B riceve prima la trasmissione, quindi A la riceve, ma non c'è connessione tra il ricevitore B e il ricevitore A e non può esserci interazione Sì, poiché si tratta di una trasmissione fuori ordine e asincrona, possiamo fare un esperimento aggiungendo codice al metodo onReceiver in B:
abortBroadcast (); // Termina la trasmissione di questa trasmissione
risultato dell'operazione:
Possiamo vedere il messaggio di errore, ovvero, la trasmissione non ordinata non è autorizzata a terminare la trasmissione. In effetti, la terminazione è inutile, perché il ricevitore A riceve ancora la trasmissione.
Diamo un'occhiata alla trasmissione ordinata, il codice deve essere modificato:
Il primo è quando si invia una trasmissione:
Trasmissione intenzione = nuova intenzione ("com.broadcast.set.broadcast");
sendOrderedBroadcast (broadcast, null);
Quindi aggiungi un metodo per terminare la trasmissione nel ricevitore B:
abortBroadcast ();
Non è necessario modificare l'altro codice, il risultato dell'operazione:
C'è solo il ricevitore B, il ricevitore A non riceve la trasmissione, perché la trasmissione viene terminata nel ricevitore B e i ricevitori successivi non possono accettarla.
Modifica il codice di seguito:
Destinatario B:
pacchetto com.broadcast.receiver;
importare android.content.BroadcastReceiver;
importare Android.content.Context;
importare Android.content.Intent;
importa android.os.Bundle;
importare android.util.Log;
/ **
* Ricevitore di trasmissione B
* @autore weijiang204321
*
*/
la classe pubblica SortBroadcastReceiverB estende BroadcastReceiver {
@Oltrepassare
public void onReceive (Context context, Intent intent) {
Log.e ("Demo:", "ricevitore di trasmissione B");
Bundle bundle = new Bundle ();
bundle.putString ("next_receiver", "destinatario della prossima trasmissione");
setResultExtras (bundle);
}
A
}
Dopo che B riceve la trasmissione, memorizza un valore e lo passa al ricevitore successivo.
Codice del ricevitore A:
pacchetto com.broadcast.receive
Il nostro altro prodotto:
