Kringkasting er delt inn i to forskjellige typer: "Normale sendinger" og "Bestilte sendinger". Vanlig kringkasting er fullstendig asynkron og kan mottas av alle kringkastingsmottakere samtidig (logisk). Effektiviteten ved levering av meldinger er relativt høy, men ulempen er at mottakeren ikke kan overføre behandlingsresultatet til neste mottaker, og den kan ikke avsluttes. Broadcast Intent forplantning; bestilt kringkasting er imidlertid basert på den prioritet som er mottatt av mottakeren (deklarert i android: prioritetsattributt til intensjonsfilterelementet, jo større tall, jo høyere prioritet, verdiområdet: -1000 til 1000. Det er også mulig Ring setPriority () til IntentFilter-objektet du vil angi), og mottakeren mottar sendingen etter tur. For eksempel, hvis nivået på A er høyere enn nivået på B, og nivået på B er høyere enn C, så sendes sendingen først til A, deretter til B, og til slutt til C. Etter at A får sendingen, blir den kan lagre data i sendingen. Når sendingen sendes til B, kan B hente data lagret av A fra sendingen.
Context.sendBroadcast ()
Det som sendes er en ordinær sending, og alle abonnenter har muligheten til å skaffe og behandle den.
Context.sendOrderedBroadcast ()
Sending er en ordnet sending. Systemet vil utføre mottakerne en etter en i henhold til den prioritet som er mottatt av mottakeren. Den forrige mottakeren har rett til å avslutte sendingen (BroadcastReceiver.abortBroadcast ()). Hvis sendingen avsluttes av forrige mottaker, kan sistnevnte Mottakeren ikke lenger få sendingen. For bestilt kringkasting kan den forrige mottakeren lagre behandlingsresultatet i sendingsintensjonen, og deretter sende det til neste mottaker.
Kringkastingsmottaker (BroadcastReceiver) brukes til å motta kringkasting Intent, og sending av kringkasting Intent realiseres ved å ringe Context.sendBroadcast () og Context.sendOrderedBroadcast (). Vanligvis kan en kringkastingsintensjon mottas av flere kringkastingsmottakere som abonnerer på denne intensjonen. Denne funksjonen ligner mottaksemottakere i JMS. Å implementere en kringkastingsmottaker metode er som følger:
Det første trinnet: definere kringkastingsmottakeren, arve BroadcastReceiver og skriv om onReceive () -metoden.
offentlig klasse IncomingSMSReceiver extendsBroadcastReceiver {
@Override public void onReceive (Contextcontext, Intentintent) {
}
}
Trinn 2: Abonner på sendingen Intens av interesse, det er to abonnementsmetoder:
Den første typen: bruk kode for å abonnere (dynamisk abonnement)
IntentFilter filter = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver mottaker = newIncomingSMSReceiver ();
registerReceiver (mottaker, filter);
Den andre typen: Abonner i node i AndroidManifest.xml-filen (statisk abonnement)
La oss se på forskjellen mellom dynamisk kringkastingsabonnement og statisk kringkastingsabonnement:
Statisk abonnementsending kalles også: resident broadcast. Når det er en kringkastingsmelding når søknaden din lukkes, kan kringkastingsmottakeren du skrev også motta den. Registreringsmetoden er AndroidManifast i applikasjonen din. .xml for abonnement.
Dynamisk abonnementssending kalles også: ikke-hjemmehørende sending. Når søknaden avsluttes, vil sendingen naturlig forsvinne. For eksempel abonnerer du på sendingen i onCreate eller onResume i aktiviteten, og du må si opp kringkastingsabonnementet i onDestory eller onPause. Ellers vil et unntak bli rapportert, slik at kringkastingsmottakeren din ikke er hjemmehørende.
Det er en mer detalj her som er de to abonnementsmetodene. Når du sender sendinger, må du ta hensyn til: Den implisitte intensjonsmetoden brukes til dynamisk registrering, så du må bruke implisitt hensikt å sende når du sender sendinger. , Ellers vil ikke kringkastingsmottakeren kunne motta sendingen. Vær oppmerksom på dette punktet. Men når du abonnerer statisk, fordi det abonnerer i AndroidMainfest.xml, er det mulig å bruke display Intent og implicit Intent når du sender sendinger (selvfølgelig er dette bare for kringkastingsmottakere definert av oss selv), så bare i tilfelle, Vi bruker generelt implisitte Intensjon om å sende sending.
La oss se på et eksempel:
Ta en titt på prosjektstrukturen:
Ta en titt på den statiske abonnementsutsendelsen:
pakke com.broadcast.demo;
importere android.app.Activity;
importere android.content.Intent;
importere android.os.Bundle;
importere android.view.View;
importere android.view.View.OnClickListener;
importere android.widget.Button;
importere com.example.androidbroadcastdemo.R;
/ **
* Statisk abonnementssending
* @forfatter weijiang204321
*
*/
offentlig klasse StaticRegisterBroadcastActivity utvider aktivitet {
@Overstyring
beskyttet tomrom onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Button btn = (Button) findViewById (R.id.btn);
Til
btn.setOnClickListener (ny OnClickListener () {
@Overstyring
offentlig ugyldighet onClick (View v) {
// Bruk en statisk måte å registrere sendingen på, du kan bruke visningsintensjonen til å sende sendingen
Intent broadcast = new Intent ("com.broadcast.set.broadcast");
sendBroadcast (kringkasting, null);
}
Til
});
}
Til
}
Abonner i AndroidMainfest.xml:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
pakke = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<bruker-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<applikasjon
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<aktivitet
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Ikke bekymre deg for det andre innholdet for nå, som vi vil snakke om senere, her fokuserer vi bare på registrering av statiske sendinger
La oss ta en titt på mottakeren av sendingen:
pakke com.broadcast.mottaker;
importere android.content.BroadcastReceiver;
importere android.content.Context;
importere android.content.Intent;
importere android.util.Log;
/ **
* Kringkastingsmottaker
* @forfatter weijiang204321
*
*/
offentlig klasse UnSortBroadcastReceiver utvider BroadcastReceiver {
@Overstyring
public void onReceive (Kontekstkontekst, intensjonsintensjon) {
Log.e ("Intent_Action:", intention.getAction () + "");
}
}
Logikken i onReceive-metoden i kringkastingsmottakeren er veldig enkel, det vil si å skrive ut innholdet i handlingen.
Kjør programmet, resultatet er veldig enkelt, her er ikke bildet.
La oss ta en titt på dynamiske abonnementer:
pakke com.broadcast.demo;
importere android.app.Activity;
importere android.content.Intent;
importere android.content.IntentFilter;
importere android.os.Bundle;
importere android.view.View;
importere android.view.View.OnClickListener;
importere android.widget.Button;
importer com.broadcast.receiver.UnSortBroadcastReceiver;
importere com.example.androidbroadcastdemo.R;
/ **
* Bruk dynamisk måte å registrere kringkasting på
* @forfatter weijiang204321
*
*/
offentlig klasse DynamicRegisterBroadcastActivity utvider aktivitet {
Til
offentlig statisk sluttstreng NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
beskyttet UnSortBroadcastReceiver-mottaker;
Til
@Overstyring
beskyttet tomrom onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Button btn0 = (Button) findViewById (R.id.btn);
btn0.setOnClickListener (ny OnClickListener () {
offentlig ugyldighet onClick (View v) {
// Send sending
Intent it = new Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@Overstyring
beskyttet tomrom onResume () {
super.onResume ();
// Registrer deg for sending
IntentFilter counterActionFilter = ny IntentFilter (NEW_LIFEFORM_DETECTED);
mottaker = ny UnSortBroadcastReceiver ();
registerReceiver (mottaker, counterActionFilter);
}
@Overstyring
beskyttet tomrom onPause () {
super.onPause ();
// Avbryt sending
unregisterReceiver (mottaker);
}
}
Her abonnerer vi på kringkasting i onResume, og avslutter abonnementet på kringkasting i onPause.
Endre den lanserte aktiviteten til DynamicRegisterBroadcastActivity i AndroidMainfest.xml. Det andre innholdet trenger ikke endres. Kjør programmet og skriv ut resultatet er veldig enkelt, så jeg ser ikke bildet her.
La oss ta en titt på bestilt kringkasting og uordnet kringkasting
Vi har allerede nevnt dette i begynnelsen, la oss ta en titt på uordnet kringkasting:
Først definerer vi to kringkastingsmottakere:
Den første kringkastingsmottakeren:
pakke com.broadcast.mottaker;
importere android.content.BroadcastReceiver;
importere android.content.Context;
importere android.content.Intent;
importere android.util.Log;
/ **
* Kringkastermottaker A
* @forfatter weijiang204321
*
*/
offentlig klasse SortBroadcastReceiverA utvider BroadcastReceiver {
@Overstyring
public void onReceive (Kontekstkontekst, intensjonsintensjon) {
Log.e ("Demo:", "kringkastingsmottaker A");
}
}
Den andre kringkastingsmottakeren:
pakke com.broadcast.mottaker;
importere android.content.BroadcastReceiver;
importere android.content.Context;
importere android.content.Intent;
importere android.util.Log;
/ **
* Kringkastermottaker B
* @forfatter weijiang204321
*
*/
offentlig klasse SortBroadcastReceiverB utvider BroadcastReceiver {
@Overstyring
public void onReceive (Kontekstkontekst, intensjonsintensjon) {
Log.e ("Demo:", "Broadcast B");
}
Til
Til
}
Abonner på kringkasting i AndroidMainfest.xml
operasjonsresultat:
Løpsresultatet er litt rart. Hvorfor er mottaker B foran og mottaker A bak? Årsaken er at når vi abonnerer på sendingen i AndroidMainfest.xml, setter vi android: prioritert attributtverdi i hensiktsfilteret. Jo større verdi, jo høyere prioritet. , Prioriteten til mottaker B er 1000, prioriteten til mottaker A er 999, så B mottar sendingen først, og deretter mottar A den, men det er ingen forbindelse mellom mottaker B og mottaker A, og det kan ikke være noen interaksjon Ja, fordi dette er en ikke-bestilt kringkasting og asynkron, kan vi gjøre et eksperiment ved å legge til kode i onReceiver-metoden i B:
abortBroadcast (); // Avslutte overføringen av denne sendingen
operasjonsresultat:
Vi kan se ledetekstfeilen, det vil si at ikke-bestilt kringkasting ikke har lov til å avslutte sendingen. Oppsigelse er faktisk ubrukelig, fordi mottaker A fremdeles mottar sendingen.
La oss ta en titt på ordnet kringkasting, koden må endres:
Den første er når du sender en sending:
Intent broadcast = new Intent ("com.broadcast.set.broadcast");
sendOrderedBroadcast (kringkasting, null);
Deretter legger du til en metode for å avslutte sendingen i B-mottakeren:
abortBroadcast ();
Den andre koden trenger ikke endres, driftsresultatet:
Det er bare mottaker B, mottaker A mottar ikke sendingen, fordi sendingen avsluttes i mottaker B, og de påfølgende mottakerne kan ikke godta den.
Endre koden nedenfor:
Mottaker B:
pakke com.broadcast.mottaker;
importere android.content.BroadcastReceiver;
importere android.content.Context;
importere android.content.Intent;
importere android.os.Bundle;
importere android.util.Log;
/ **
* Kringkastermottaker B
* @forfatter weijiang204321
*
*/
offentlig klasse SortBroadcastReceiverB utvider BroadcastReceiver {
@Overstyring
public void onReceive (Kontekstkontekst, intensjonsintensjon) {
Log.e ("Demo:", "kringkastingsmottaker B");
Pakkepakke = ny pakke ();
bundle.putString ("neste mottaker", "neste kringkastingsmottaker");
setResultExtras (pakke);
}
Til
}
Etter at B mottar sendingen, lagrer den noe verdi og overfører den til neste mottaker.
Mottaker A-kode:
pakke com.broadcast.reciveive
Vår andre produkt:
