Oddajanje je razdeljeno na dve različni vrsti: "Običajne oddaje" in "Naročene oddaje". Navadna oddaja je popolnoma asinhrona in jo lahko prejmejo vsi sprejemniki oddajanja hkrati (logično). Učinkovitost dostave sporočil je sorazmerno visoka, pomanjkljivost pa je, da sprejemnik ne more posredovati rezultata obdelave naslednjemu sprejemniku in ga ni mogoče zaključiti. Razširjanje namena razširjanja; vendar razporejena oddaja temelji na prednosti, ki jo je določil sprejemnik (navedena v android: attribute priority elementa filtra namena, večje je število, večja je prednost, obseg vrednosti: -1000 do 1000. Prav tako je mogoče Pokličite setPriority () predmeta IntentFilter, ki ga želite nastaviti), in prejemnik prejme oddajo po vrsti. Če je na primer raven A višja od ravni B in raven B višja od C, se oddaja najprej pošlje A, nato B in na koncu C. Ko A odda oddajo, lahko shrani podatke v oddaji. Ko je oddaja poslana v B, lahko B iz oddaje pridobi podatke, ki jih shrani A.
Context.sendBroadcast ()
Poslano je običajno oddajanje in vsi naročniki ga imajo možnost pridobiti in obdelati.
Context.sendOrderedBroadcast ()
Pošiljanje je urejena oddaja. Sistem bo sprejemnike izvršil enega za drugim v skladu s prioriteto, ki jo je določil sprejemnik. Prejšnji sprejemnik ima pravico do prekinitve oddaje (BroadcastReceiver.abortBroadcast ()). Če oddajanje prekine prejšnji sprejemnik, slednji Sprejemnik ne more več sprejeti oddaje. Za urejeno oddajanje lahko prejšnji sprejemnik shrani rezultat obdelave v namen oddajanja in ga nato posreduje naslednjemu sprejemniku.
Oddajnik (BroadcastReceiver) se uporablja za sprejemanje oddaje Intent, pošiljanje oddaje Intent pa se izvede s klicem Context.sendBroadcast () in Context.sendOrderedBroadcast (). Običajno oddajni namen lahko prejme več sprejemnikov, ki so naročeni na ta namen. Ta funkcija je podobna sprejemnikom sporočil Topic v sistemu JMS. Metoda oddajanja sprejemnika je naslednja:
Prvi korak: definirajte oddajni sprejemnik, podedujte BroadcastReceiver in prepišite metodo onReceive ().
javni razred IncomingSMSReceiver extendsBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
2. korak: Naročite se na oddajo Namen zanimanja, obstajata dva načina naročanja:
Prva vrsta: za naročanje uporabite kodo (dinamična naročnina)
Filter IntentFilter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver sprejemnik = newIncomingSMSReceiver ();
registerReceiver (sprejemnik, filter);
Druga vrsta: Naročite se na vozlišče v datoteki AndroidManifest.xml (statična naročnina)
Oglejmo si razliko med naročnino na dinamično oddajanje in naročnino na statično oddajanje:
Statična naročnina se imenuje tudi: rezidenčna oddaja. Če je vaša aplikacija zaprta, lahko v primeru oddanega sporočila prejme tudi sprejemnik, ki ste ga napisali. Njegov način registracije je AndroidManifast v vaši aplikaciji. .xml za naročnino.
Dinamična naročnina se imenuje tudi: nerezidenčna oddaja. Ko se aplikacija konča, oddaja naravno izgine. Na primer, naročite se na oddajo v onCreate ali onResume v dejavnosti, naročnino na oddajo pa morate preklicati v onDestory ali onPause. V nasprotnem primeru bo prijavljena izjema, zato bo vaš oddajnik nerezident.
Tu je še ena podrobnost, to sta dva načina naročanja. Pri pošiljanju oddaj morate biti pozorni: Metoda implicitnega namena se uporablja za dinamično registracijo, zato morate za pošiljanje oddaj uporabiti implicitni namen. , V nasprotnem primeru sprejemnik oddajanja ne bo mogel sprejeti oddaje. Bodite pozorni na to točko. Ko pa se naročite statično, ker je naročen na AndroidMainfest.xml, je pri pošiljanju oddaj mogoče uporabiti prikazni namen in implicitni namen (seveda to velja samo za sprejemnike oddajanja, ki smo jih sami določili), zato za vsak slučaj običajno uporabljamo implicitne Namen pošiljanja oddaje.
Oglejmo si primer:
Oglejte si strukturo projekta:
Oglejte si statično oddajo naročnine:
paket com.broadcast.demo;
uvoz android.app.Activity;
uvoz android.content.Intent;
uvoz android.os.Bundle;
uvoz android.view.View;
uvoz android.view.View.OnClickListener;
uvoz android.widget.Button;
uvoz com.example.androidbroadcastdemo.R;
/ **
* Statična oddaja naročnine
* @avtor weijiang204321
*
*/
javni razred StaticRegisterBroadcastActivity razširja dejavnost {
@Prevedi
zaščitena void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Gumb btn = (Gumb) findViewById (R.id.btn);
Da
btn.setOnClickListener (novo OnClickListener () {
@Prevedi
javna praznina onClick (Pogled v) {
// Uporabite statičen način za registracijo oddaje, lahko uporabite namen zaslona za pošiljanje oddaje
Oddaja namena = nova namera ("com.broadcast.set.broadcast");
sendBroadcast (oddaja, nično);
}
Da
});
}
Da
}
Naročite se na AndroidMainfest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
paket = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<uses-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<aplikacija
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<dejavnost
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Za ostalo vsebino za zdaj ne skrbite, o čemer bomo govorili kasneje, tu se osredotočamo le na registracijo statičnih oddaj
Oglejmo si sprejemnik oddaje:
paket com.broadcast.receiver;
uvoz android.content.BroadcastReceiver;
uvoz android.content.Context;
uvoz android.content.Intent;
uvoz android.util.Log;
/ **
* Oddajni sprejemnik
* @avtor weijiang204321
*
*/
javni razred UnSortBroadcastReceiver razširja BroadcastReceiver {
@Prevedi
javna void onReceive (kontekst konteksta, namen namere) {
Log.e ("Intent_Action:", intent.getAction () + "");
}
}
Logika metode onReceive v oddajnem sprejemniku je zelo preprosta, to je tiskanje vsebine akcije.
Zaženite program, rezultat je zelo preprost, tukaj ni slike.
Oglejmo si dinamične naročnine:
paket com.broadcast.demo;
uvoz android.app.Activity;
uvoz android.content.Intent;
uvoz android.content.IntentFilter;
uvoz android.os.Bundle;
uvoz android.view.View;
uvoz android.view.View.OnClickListener;
uvoz android.widget.Button;
uvoz com.broadcast.receiver.UnSortBroadcastReceiver;
uvoz com.example.androidbroadcastdemo.R;
/ **
* Uporabite dinamičen način za registracijo oddaje
* @avtor weijiang204321
*
*/
javni razred DynamicRegisterBroadcastActivity razširja dejavnost {
Da
javni statični končni niz NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
zaščiten sprejemnik UnSortBroadcastReceiver;
Da
@Prevedi
zaščitena void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Gumb btn0 = (Gumb) findViewById (R.id.btn);
btn0.setOnClickListener (novo OnClickListener () {
javna praznina onClick (Pogled v) {
// Pošlji oddajo
Namen it = nov namen (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@Prevedi
zaščitena praznina onResume () {
super.onResume ();
// Registracija za oddajo
IntentFilter counterActionFilter = nov IntentFilter (NEW_LIFEFORM_DETECTED);
sprejemnik = nov UnSortBroadcastReceiver ();
registerReceiver (sprejemnik, counterActionFilter);
}
@Prevedi
zaščitena praznina onPause () {
super.onPause ();
// Prekliči oddajo
odjavi registra (sprejemnik);
}
}
Tukaj smo naročeni na oddajanje v onResume in se odjavimo na oddajanje v onPause.
Spremenjeno dejavnost spremenite v DynamicRegisterBroadcastActivity v AndroidMainfest.xml. Druge vsebine ni treba spreminjati. Zaženite program in natisnite rezultat, je zelo preprost, zato slike tukaj ne bom videl.
Oglejmo si urejeno oddajanje in neurejeno oddajanje
To smo že omenili na začetku, poglejmo si neurejeno oddajanje:
Najprej določimo dva oddajna sprejemnika:
Prvi oddajnik:
paket com.broadcast.receiver;
uvoz android.content.BroadcastReceiver;
uvoz android.content.Context;
uvoz android.content.Intent;
uvoz android.util.Log;
/ **
* Oddajalec A
* @avtor weijiang204321
*
*/
javni razred SortBroadcastReceiverA razširja BroadcastReceiver {
@Prevedi
javna void onReceive (kontekst konteksta, namen namere) {
Log.e ("Demo:", "oddajni sprejemnik A");
}
}
Drugi oddajnik:
paket com.broadcast.receiver;
uvoz android.content.BroadcastReceiver;
uvoz android.content.Context;
uvoz android.content.Intent;
uvoz android.util.Log;
/ **
* Oddajnik B
* @avtor weijiang204321
*
*/
javni razred SortBroadcastReceiverB razširja BroadcastReceiver {
@Prevedi
javna void onReceive (kontekst konteksta, namen namere) {
Log.e ("Demo:", "Broadcast B");
}
Da
Da
}
Naročite se na oddajanje v AndroidMainfest.xml
rezultat operacije:
Rezultat teka je nekoliko čuden. Zakaj je sprejemnik B spredaj, sprejemnik A pa zadaj? Razlog je v tem, da ko se naročimo na oddajo v AndroidMainfest.xml, nastavimo vrednost atributa android: priority v filtru namena. Večja kot je vrednost, večja je prednost. , Prednost sprejemnika B je 1000, prednost sprejemnika A je 999, zato B prejme oddajo najprej, nato pa jo prejme A, vendar med sprejemnikom B in sprejemnikom A ni povezave in ne more biti interakcije Da, ker gre za oddajo, ki ni v redu in je asinhrona, lahko izvedemo eksperiment tako, da metodi onReceiver v B dodamo kodo:
abortBroadcast (); // Prekinite prenos te oddaje
rezultat operacije:
Vidimo takojšnjo napako, to pomeni, da neurejena oddaja ne sme končati oddaje. Dejansko je prekinitev neuporabna, ker sprejemnik A še vedno sprejema oddajanje.
Oglejmo si urejeno oddajanje, kodo je treba spremeniti:
Prva je pri pošiljanju oddaje:
Oddaja namena = nova namera ("com.broadcast.set.broadcast");
sendOrderedBroadcast (oddaja, nično);
Nato dodajte metodo za prekinitev oddajanja v sprejemniku B:
abortBroadcast ();
Druge kode ni treba spreminjati, rezultat operacije:
Obstaja samo sprejemnik B, sprejemnik A ne sprejema oddaje, ker je oddaja zaključena v sprejemniku B, in naslednji sprejemniki tega ne morejo sprejeti.
Spremenite spodnjo kodo:
Prejemnik B:
paket com.broadcast.receiver;
uvoz android.content.BroadcastReceiver;
uvoz android.content.Context;
uvoz android.content.Intent;
uvoz android.os.Bundle;
uvoz android.util.Log;
/ **
* Oddajnik B
* @avtor weijiang204321
*
*/
javni razred SortBroadcastReceiverB razširja BroadcastReceiver {
@Prevedi
javna void onReceive (kontekst konteksta, namen namere) {
Log.e ("Demo:", "oddajni sprejemnik B");
Snop svežnja = nov Bundle ();
bundle.putString ("naslednji_prejemnik", "naslednji sprejemnik oddajanja");
setResultExtras (sveženj);
}
Da
}
Ko B sprejme oddajo, shrani nekaj vrednosti in jo posreduje naslednjemu sprejemniku.
Koda sprejemnika A:
paket com.broadcast.receive
Naš drugi izdelek:
