Transmisje dzielą się na dwa rodzaje: „Audycje zwykłe” i „Audycje zamówione”. Zwykła transmisja jest całkowicie asynchroniczna i może być odbierana przez wszystkich odbiorców w tym samym czasie (logicznie). Wydajność dostarczania wiadomości jest stosunkowo wysoka, ale wadą jest to, że odbiorca nie może przekazać wyniku przetwarzania do następnego odbiorcy i nie można go zakończyć. Rozpowszechnianie intencji transmisji; jednak rozgłaszanie zamówione odbywa się na podstawie zadeklarowanego przez odbiorcę priorytetu (zadeklarowanego w atrybucie android:priority elementu zamierzającego filtrować, im większa liczba, tym wyższy priorytet, zakres wartości: -1000 do 1000. Jest to również możliwe Wywołaj metodę setPriority() obiektu IntentFilter, aby ustawić), a odbiorca po kolei odbierze rozgłoszenie. Na przykład, jeśli poziom A jest wyższy niż poziom B, a poziom B jest wyższy niż C, wówczas rozgłoszenie jest najpierw transmitowane do A, następnie do B, a na koniec do C. Po odebraniu rozgłoszenia, może przechowywać dane w transmisji. Kiedy transmisja jest wysyłana do B, B może pobrać dane przechowywane przez A z transmisji.
Kontekst.sendBroadcast()
Wysyłana jest zwykła transmisja, a wszyscy abonenci mają możliwość jej otrzymania i przetworzenia.
Context.sendOrderedBroadcast()
Wysyłanie jest uporządkowaną transmisją. System wykona kolejno odbiorniki zgodnie z zadeklarowanym przez odbiornik priorytetem. Poprzedni odbiorca ma prawo przerwać rozgłaszanie (BroadcastReceiver.abortBroadcast()). Jeśli transmisja zostanie zakończona przez poprzedniego odbiorcę, ten ostatni Odbiorca nie może już odbierać transmisji. W przypadku rozgłaszania uporządkowanego poprzedni odbiorca może zapisać wynik przetwarzania w rozgłoszeniu Intent, a następnie przekazać go do następnego odbiorcy.
Odbiornik rozgłoszeniowy (BroadcastReceiver) jest używany do odbierania Intencji rozgłoszeniowej, a wysyłanie Intencji rozgłoszeniowej jest realizowane przez wywołanie Context.sendBroadcast() i Context.sendOrderedBroadcast(). Zwykle Intencja rozgłoszeniowa może być odbierana przez wiele odbiorników rozgłoszeniowych subskrybujących tę Intencję. Ta funkcja jest podobna do odbiorników komunikatów Topic w JMS. Aby zaimplementować metodę odbiornika rozgłoszeniowego, należy wykonać następujące czynności:
Pierwszy krok: zdefiniuj odbiornik rozgłoszeniowy, odziedzicz BroadcastReceiver i przepisz metodę onReceive().
klasa publiczna PrzychodząceSMSReceiver extendsBroadcastReceiver {
@Override public void onReceive (kontekst kontekstowy, intencja) {
}
}
Krok 2: Zapisz się na audycję Zainteresowany, istnieją dwie metody subskrypcji:
Pierwszy typ: użyj kodu do subskrypcji (subskrypcja dynamiczna)
Filtr IntentFilter = newIntentFilter("android.provider.Telephony.SMS_RECEIVED");
Odbiornik przychodzącego SMSReceiver = newIncomingSMSReceiver();
registerReceiver(odbiornik, filtr);
Drugi typ: Subskrybuj w węzeł w pliku AndroidManifest.xml (subskrypcja statyczna)
Przyjrzyjmy się różnicy między dynamiczną subskrypcją transmisji a statyczną subskrypcją transmisji:
Emisja statyczna w abonamencie nazywana jest także: audycją rezydentną. Gdy Twoja aplikacja zostanie zamknięta, jeśli pojawi się komunikat rozgłoszeniowy, napisany przez Ciebie odbiornik rozgłoszeniowy również może go odebrać. Jego metodą rejestracji jest AndroidManifast w Twojej aplikacji. .xml do subskrypcji.
Dynamiczna transmisja subskrypcyjna nazywana jest także: transmisją nierezydentną. Po zakończeniu aplikacji transmisja naturalnie zniknie. Na przykład subskrybujesz transmisję w onCreate lub onResume w działaniu i musisz anulować subskrypcję transmisji w onDestory lub onPause. W przeciwnym razie zostanie zgłoszony wyjątek, więc Twój odbiorca będzie nierezydentem.
Jest jeszcze jeden szczegół, a mianowicie dwie metody subskrypcji. Podczas wysyłania rozgłoszeń należy zwrócić uwagę na: Metoda niejawnej intencji jest używana do rejestracji dynamicznej, dlatego podczas wysyłania rozgłoszeń należy użyć niejawnej intencji wysyłania. , W przeciwnym razie odbiornik nie będzie mógł odbierać programu. Zwróć uwagę na ten punkt. Ale subskrybując statycznie, ponieważ jest to subskrybowane w AndroidMainfest.xml, możliwe jest użycie display Intent i implicit Intent podczas wysyłania transmisji (oczywiście dotyczy to tylko zdefiniowanych przez nas odbiorników transmisji), więc na wszelki wypadek generalnie używamy implicit Zamiar wysłania transmisji.
Spójrzmy na przykład:
Spójrz na strukturę projektu:
Spójrz na statyczną transmisję subskrypcyjną:
pakiet com.broadcast.demo;
importuj android.app.Activity;
importuj android.content.Intent;
importuj android.os.Bundle;
importuj android.view.View;
importuj android.view.View.OnClickListener;
importuj android.widget.Button;
import com.example.androidbroadcastdemo.R;
/ **
* Statyczna transmisja subskrypcyjna
* @autor weijiang204321
*
*/
klasa publiczna StaticRegisterBroadcastActivity rozszerza działanie {
@Nadpisanie
protected void onCreate (Bundle savingInstanceState) {
super.onCreate (saveInstanceState);
setContentView (R.layout.activity_main);
Przycisk btn = (Przycisk)findViewById(R.id.btn);
Do
btn.setOnClickListener(nowy OnClickListener(){
@Nadpisanie
public void onClick (View v) {
//Użyj statycznego sposobu rejestracji emisji, możesz użyć zamiaru wyświetlania, aby wysłać transmisję
Transmisja intencji = new Intent("com.broadcast.set.broadcast");
sendBroadcast(transmisja,null);
}
Do
});
}
Do
}
Subskrybuj w AndroidMainfest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.androidbroadcastdemo"
android:kod wersji="1"
android:nazwa_wersji="1.0">
<używa-sdk
android:minSdkVersion="8"
android:targetSdkVersion="18" />
<aplikacja
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/nazwa_aplikacji"
android:theme="@style/Motyw aplikacji">
<aktywność
android:name="com.broadcast.demo.StaticRegisterBroadcastActivity"
android:label="@string/nazwa_aplikacji">
Na razie nie martw się o inne treści, o czym porozmawiamy później, tutaj skupiamy się tylko na rejestracji transmisji statycznych
Przyjrzyjmy się odbiorcy transmisji:
pakiet com.broadcast.receiver;
importuj android.content.BroadcastReceiver;
importuj android.content.Context;
importuj android.content.Intent;
importuj android.util.Log;
/ **
* Odbiornik transmisji
* @autor weijiang204321
*
*/
klasa publiczna UnSortBroadcastReceiver rozszerza BroadcastReceiver {
@Nadpisanie
public void onReceive (kontekst kontekstowy, zamiar zamiaru) {
Log.e("Intent_Action:",intent.getAction()+"");
}
}
Logika w metodzie onReceive w odbiorniku rozgłoszeniowym jest bardzo prosta, polega na wydrukowaniu zawartości Akcji.
Uruchom program, wynik jest bardzo prosty, tutaj nie ma obrazu.
Przyjrzyjmy się subskrypcjom dynamicznym:
pakiet com.broadcast.demo;
importuj android.app.Activity;
importuj android.content.Intent;
importuj android.content.IntentFilter;
importuj android.os.Bundle;
importuj android.view.View;
importuj android.view.View.OnClickListener;
importuj android.widget.Button;
importuj com.broadcast.receiver.UnSortBroadcastReceiver;
import com.example.androidbroadcastdemo.R;
/ **
* Użyj dynamicznego sposobu rejestracji transmisji
* @autor weijiang204321
*
*/
klasa publiczna DynamicRegisterBroadcastActivity rozszerza działanie {
Do
public static final String NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
chroniony odbiornik UnSortBroadcastReceiver;
Do
@Nadpisanie
protected void onCreate (Bundle savingInstanceState) {
super.onCreate (saveInstanceState);
setContentView (R.layout.activity_main);
Przycisk btn0 = (Przycisk) findViewById(R.id.btn);
btn0.setOnClickListener(nowy OnClickListener() {
public void onClick (View v) {
//Wyślij transmisję
Zamiar to = nowy zamiar (NEW_LIFEFORM_DETECTED);
wyślijBroadcast(to);
}
});
}
@Nadpisanie
protected void onResume () {
super.onResume ();
//Zarejestruj się do transmisji
IntentFilter counterActionFilter = nowy IntentFilter(NEW_LIFEFORM_DETECTED);
odbiornik = new UnSortBroadcastReceiver();
registerReceiver(odbiornik, counterActionFilter);
}
@Nadpisanie
chroniony void onPause() {
super.onPause();
//Anuluj transmisję
unregisterReceiver(odbiornik);
}
}
Tutaj subskrybujemy transmisję w onResume i anulujemy subskrypcję transmisji w onPause.
Zmień uruchomioną aktywność na DynamicRegisterBroadcastActivity w pliku AndroidMainfest.xml. Pozostałe treści nie wymagają modyfikacji. Uruchom program i wydrukuj wynik jest bardzo prosty, więc nie zobaczę tutaj obrazu.
Przyjrzyjmy się rozgłaszaniu uporządkowanemu i nieuporządkowanemu
Wspomnieliśmy już o tym na początku, spójrzmy na nieuporządkowane nadawanie:
Najpierw definiujemy dwa odbiorniki rozgłoszeniowe:
Pierwszy odbiornik nadawczy:
pakiet com.broadcast.receiver;
importuj android.content.BroadcastReceiver;
importuj android.content.Context;
importuj android.content.Intent;
importuj android.util.Log;
/ **
* Odbiornik transmisji A
* @autor weijiang204321
*
*/
klasa publiczna SortBroadcastReceiverA rozszerza BroadcastReceiver{
@Nadpisanie
public void onReceive (kontekst kontekstowy, zamiar zamiaru) {
Log.e("Demonstracja:","Odbiornik transmisji A");
}
}
Drugi odbiornik nadawczy:
pakiet com.broadcast.receiver;
importuj android.content.BroadcastReceiver;
importuj android.content.Context;
importuj android.content.Intent;
importuj android.util.Log;
/ **
* Odbiornik transmisji B
* @autor weijiang204321
*
*/
klasa publiczna SortBroadcastReceiverB rozszerza BroadcastReceiver{
@Nadpisanie
public void onReceive (kontekst kontekstowy, zamiar zamiaru) {
Log.e("Demonstracja:","Emisja B");
}
Do
Do
}
Subskrybuj transmisję w pliku AndroidMainfest.xml
wynik operacji:
Wynik biegu jest nieco dziwny. Dlaczego odbiornik B jest z przodu, a odbiornik A z tyłu? Powodem jest to, że kiedy subskrybujemy transmisję w AndroidMainfest.xml, ustawiamy wartość atrybutu android:priority w filtrze zamiarów. Im większa wartość, tym wyższy priorytet. , Priorytet odbiornika B wynosi 1000, priorytet odbiornika A wynosi 999, więc B odbiera transmisję jako pierwszy, a następnie odbiera go A, ale nie ma połączenia między odbiornikiem B a odbiornikiem A i nie może być żadnej interakcji Tak, ponieważ jest to rozgłaszanie poza kolejnością i asynchroniczne, możemy przeprowadzić eksperyment, dodając kod do metody onReceiver w B:
abortBroadcast();//Zakończ transmisję tej transmisji
wynik operacji:
Widzimy błąd monitu, to znaczy nie zamówiona transmisja nie może zakończyć transmisji. W rzeczywistości zakończenie jest bezużyteczne, ponieważ odbiornik A nadal odbiera transmisję.
Przyjrzyjmy się uporządkowanemu rozgłaszaniu, kod wymaga modyfikacji:
Pierwszym z nich jest wysyłanie transmisji:
Transmisja intencji = new Intent("com.broadcast.set.broadcast");
sendOrderedBroadcast(transmisja,null);
Następnie dodaj metodę zakończenia transmisji w odbiorniku B:
przerwanie transmisji();
Innego kodu nie trzeba modyfikować, wynik operacji:
Jest tylko odbiornik B, odbiornik A nie odbiera transmisji, ponieważ transmisja jest zakończona w odbiorniku B, a kolejni odbiorcy nie mogą jej odebrać.
Zmodyfikuj poniższy kod:
Odbiorca B:
pakiet com.broadcast.receiver;
importuj android.content.BroadcastReceiver;
importuj android.content.Context;
importuj android.content.Intent;
importuj android.os.Bundle;
importuj android.util.Log;
/ **
* Odbiornik transmisji B
* @autor weijiang204321
*
*/
klasa publiczna SortBroadcastReceiverB rozszerza BroadcastReceiver{
@Nadpisanie
public void onReceive (kontekst kontekstowy, zamiar zamiaru) {
Log.e("Demonstracja:","Odbiornik transmisji B");
Pakiet bundle = nowy Bundle ();
bundle.putString("next_receiver", "następny odbiornik transmisji");
setResultExtras(pakiet);
}
Do
}
Po odebraniu transmisji B zapisuje pewną wartość i przekazuje ją następnemu odbiorcy.
Kod odbiorcy A:
pakiet com.broadcast.receive
Nasze inne produkty:
