A műsorszórás két különböző típusra oszlik: "Normál adások" és "Rendezett adások". A közönséges adás teljesen aszinkron, és minden adás vevője egyszerre fogadhatja (logikusan). Az üzenet kézbesítésének hatékonysága viszonylag magas, de hátránya, hogy a vevő nem tudja átadni a feldolgozási eredményt a következő vevőnek, és nem lehet befejezni. Broadcast Intent terjesztése; a megrendelt sugárzás azonban a vevő által deklarált prioritáson alapul (deklarálva az szándék-szűrő elem android: prioritás attribútumában, minél nagyobb a szám, annál nagyobb a prioritás, az értéktartomány: -1000 és 1000 között.) lehetséges Hívja meg a beállítandó IntentFilter objektum setPriority () beállítását, és a címzett felveszi az adást. Például, ha A szintje magasabb, mint B szintje, és B szintje magasabb, mint C, akkor az adást először A-nak, majd B-nek, végül C-nek továbbítják. Miután A megkapja az adást, adatokat tárolhat az adásban. Amikor az adást B-nek küldik, B megszerezheti az A által tárolt adatokat az adásból.
Context.sendBroadcast ()
Az elküldött egy közönséges adás, és minden előfizetőnek lehetősége van megszerezni és feldolgozni.
Context.sendOrderedBroadcast ()
A küldés rendezett közvetítés. A rendszer egyenként végrehajtja a vevőket a vevő által deklarált prioritásnak megfelelően. Az előző vevőnek joga van befejezni az adást (BroadcastReceiver.abortBroadcast ()). Ha az adást az előző vevő fejezi be, az utóbbi A vevő már nem tudja elérni az adást. Rendelt adás esetén az előző vevő tárolja a feldolgozás eredményét a broadcast szándékban, majd továbbíthatja a következő vevőnek.
A Broadcast vevő (BroadcastReceiver) a műsorszórási szándék fogadására szolgál, és a műsorszórási szándék elküldése a Context.sendBroadcast () és a Context.sendOrderedBroadcast () meghívásával valósul meg. Általában egy műsorszórási szándékot több, erre a szándékra előfizető műsorvevő fogadhat. Ez a szolgáltatás hasonló a JMS Témakör üzenetvevőihez. Az adás vevő módszerének megvalósítása a következő:
Az első lépés: definiálja a sugárzott vevőt, örökölje a BroadcastReceiver-t és írja át az onReceive () metódust.
public class IncomingSMSReceiver kiterjeszti a BroadcastReceiver {
@Orride public void onReceive (Contextcontext, Intentintent) {
}
}
2. lépés: Iratkozzon fel a kívánt érdeklődésre, két előfizetési módszer létezik:
Az első típus: használjon kódot az előfizetéshez (dinamikus előfizetés)
IntentFilter szűrő = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver vevő = newIncomingSMSReceiver ();
registerReceiver (vevő, szűrő);
A második típus: Iratkozzon fel a csomópont az AndroidManifest.xml fájlban (statikus előfizetés)
Vessünk egy pillantást a dinamikus sugárzott előfizetés és a statikus műsor-előfizetés közötti különbségre:
A statikus előfizetéses közvetítést más néven: rezidens közvetítésnek nevezik. Ha az alkalmazás lezárult, és van üzenet, akkor az általad írt adóvevő is meg tudja fogadni. Regisztrációs módja az AndroidManifast az alkalmazásban. .xml előfizetéshez.
A dinamikus előfizetéses közvetítést más néven: nem rezidens közvetítésnek nevezik. Amikor az alkalmazás véget ér, az adás természetesen eltűnik. Például feliratkozik a közvetítésre a tevékenység onCreate vagy onResume programjában, és le kell mondania a közvetítés előfizetését az onDestory vagy az onPause szolgáltatásban. Ellenkező esetben kivételről számolunk be, így az adás vevője nem rezidens lesz.
Van még egy részlet, ez a két előfizetési módszer. Közvetítések küldésekor ügyelnie kell a következőkre: Az implicit szándék metódust használják a dinamikus regisztrációhoz, ezért sugárzások küldésénél implicit szándékot kell használnia a küldésre. , Ellenkező esetben a vevő nem tudja fogadni az adást. Figyeljen erre a pontra. De statikus előfizetés esetén, mivel az AndroidMainfest.xml fájlra feliratkozott, lehetőség van az Intent és implicit Intent megjelenítésre is adások küldésénél (természetesen ez csak a saját magunk által meghatározott műsorszórókra vonatkozik), ezért csak arra az esetre használjuk általában Közvetítés küldésének szándéka.
Nézzünk meg egy példát:
Vessen egy pillantást a projekt felépítésére:
Vessen egy pillantást a statikus előfizetéses közvetítésre:
com.broadcast.demo csomag;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
android.view.View.OnClickListener importálása;
import android.widget.Button;
importálja a com.example.androidbroadcastdemo.R;
/ **
* Statikus előfizetéses közvetítés
* @szerző weijiang204321
*
*/
a public class StaticRegisterBroadcastActivity kiterjeszti a tevékenységet {
@Override
védett void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Gomb btn = (Gomb) findViewById (R.id.btn);
Nak nek
btn.setOnClickListener (új OnClickListener () {
@Override
public void onClick (Nézet v) {
// Statikus módon regisztrálhatja az adást, a megjelenítés szándékával pedig elküldheti az adást
Szándékközvetítés = új szándék ("com.broadcast.set.broadcast");
sendBroadcast (broadcast, null);
}
Nak nek
});
}
Nak nek
}
Feliratkozás az AndroidMainfest.xml fájlra:
<? Xml version = "1.0" encoding = "UTF-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<uses-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<alkalmazás
android: allowBackup = "true"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<tevékenység
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
Egyelőre ne aggódjon a többi tartalom miatt, amiről később beszélünk, itt csak a statikus adások regisztrálására összpontosítunk
Vessünk egy pillantást az adás vevőjére:
csomag com.broadcast.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
/ **
* Broadcast vevő
* @szerző weijiang204321
*
*/
public class UnSortBroadcastReceiver kiterjeszti a BroadcastReceiver {
@Override
public void onReceive (Kontextus kontextus, Intent szándék) {
Log.e ("Intent_Action:", szándék.getAction () + "");
}
}
A broadcast vevő onReceive metódusának logikája nagyon egyszerű, vagyis az Action tartalmának kinyomtatása.
Futtassa a programot, az eredmény nagyon egyszerű, itt nem ez a kép.
Vessünk egy pillantást a dinamikus előfizetésekre:
com.broadcast.demo csomag;
import android.app.Activity;
import android.content.Intent;
android.content.IntentFilter importálása;
import android.os.Bundle;
import android.view.View;
android.view.View.OnClickListener importálása;
import android.widget.Button;
import com.broadcast.receiver.UnSortBroadcastReceiver;
importálja a com.example.androidbroadcastdemo.R;
/ **
* Dinamikus módon regisztrálhatja a sugárzást
* @szerző weijiang204321
*
*/
a nyilvános osztály DynamicRegisterBroadcastActivity kiterjeszti a tevékenységet {
Nak nek
public static final String NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
védett UnSortBroadcastReceiver vevő;
Nak nek
@Override
védett void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
setContentView (R.layout.activity_main);
Gomb btn0 = (Gomb) findViewById (R.id.btn);
btn0.setOnClickListener (új OnClickListener () {
public void onClick (Nézet v) {
// Adás küldése
Intent it = új szándék (NEW_LIFEFORM_DETECTED);
sendBroadcast (it);
}
});
}
@Override
védett void onResume () {
super.onResume ();
// Regisztráció az adáshoz
IntentFilter counterActionFilter = új IntentFilter (NEW_LIFEFORM_DETECTED);
vevő = új UnSortBroadcastReceiver ();
registerReceiver (vevő, counterActionFilter);
}
@Override
védett void onPause () {
szuper.onPause ();
// Közvetítés megszakítása
unregisterReceiver (vevő);
}
}
Itt feliratkozunk az onResume műsorszolgáltatására, és leiratkozunk az onPause műsorszolgáltatásra.
Az indított tevékenységet állítsa DynamicRegisterBroadcastActivity-re az AndroidMainfest.xml fájlban. A másik tartalmat nem kell módosítani. Futtassa a programot, és az eredmény kinyomtatása nagyon egyszerű, ezért itt nem látom a képet.
Vessünk egy pillantást a megrendelt műsorszórásra és a rendezetlen műsorszórásra
Ezt már az elején említettük, vessünk egy pillantást a rendezetlen műsorszolgáltatásra:
Először két adás vevőt határozunk meg:
Az első adás vevője:
csomag com.broadcast.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
/ **
* Műsorszóró vevő A
* @szerző weijiang204321
*
*/
public class SortBroadcastReceiverA kiterjeszti a BroadcastReceiver {
@Override
public void onReceive (Kontextus kontextus, Intent szándék) {
Log.e ("Demo:", "A vevő vevő");
}
}
A második adás vevője:
csomag com.broadcast.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
/ **
* Broadcast vevő B
* @szerző weijiang204321
*
*/
public class SortBroadcastReceiverB kiterjeszti a BroadcastReceiver {
@Override
public void onReceive (Kontextus kontextus, Intent szándék) {
Log.e ("Demo:", "Broadcast B");
}
Nak nek
Nak nek
}
Iratkozzon fel az AndroidMainfest.xml fájlra
működési eredmény:
A futási eredmény kissé furcsa. Miért van a B vevő elöl és az A vevő hátul? Ennek oka az, hogy amikor feliratkozunk az AndroidMainfest.xml fájlra, akkor a szándék-szűrőben beállítjuk az android: priority attribútum értékét. Minél nagyobb az érték, annál nagyobb a prioritás. , A B vevő prioritása 1000, az A vevő prioritása 999, tehát B először fogadja az adást, majd A fogadja, de a B vevő és az A vevő között nincs kapcsolat, és nem lehet interakció Igen, Mivel ez egy soron kívüli sugárzás és aszinkron, kísérletet tehetünk úgy, hogy kódot adunk a B onReceiver metódusához:
abortBroadcast (); // Állítsa le a közvetítés továbbítását
működési eredmény:
Láthatjuk az azonnali hibát, vagyis a nem rendelt adás nem zárhatja le az adást. Valójában a felmondás haszontalan, mert az A vevő továbbra is fogadja az adást.
Vessünk egy pillantást a rendezett közvetítésre, a kódot módosítani kell:
Az első a közvetítés küldésekor:
Szándékközvetítés = új szándék ("com.broadcast.set.broadcast");
sendOrderedBroadcast (broadcast, null);
Ezután adjon hozzá egy módszert az adás leállításához a B vevőben:
abortBroadcast ();
A másik kódot nem kell módosítani, a művelet eredménye:
Csak B vevő van, az A vevő nem fogadja az adást, mert a B vevőben az adás befejeződik, és a következő vevők nem tudják elfogadni.
Módosítsa az alábbi kódot:
B címzett:
csomag com.broadcast.receiver;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
/ **
* Broadcast vevő B
* @szerző weijiang204321
*
*/
public class SortBroadcastReceiverB kiterjeszti a BroadcastReceiver {
@Override
public void onReceive (Kontextus kontextus, Intent szándék) {
Log.e ("Demo:", "B vevő vevő");
Bundle bundle = új Bundle ();
bundle.putString ("következő_fogadó", "következő adás vevője");
setResultExtras (csomag);
}
Nak nek
}
Miután B megkapta az adást, eltárol bizonyos értéket és továbbítja a következő vevőnek.
A vevő kódja:
csomag com.broadcast.receive
Másik termék:
