მაუწყებლობა იყოფა ორ სხვადასხვა ტიპად: "ნორმალური მაუწყებლობა" და "შეკვეთილი მაუწყებლობა". ჩვეულებრივი მაუწყებლობა მთლიანად ასინქრონულია და მისი მიღება ყველა მაუწყებლის მიმღებს ერთდროულად შეუძლია (ლოგიკურად). შეტყობინების მიწოდების ეფექტურობა შედარებით მაღალია, მაგრამ მინუსი ის არის, რომ მიმღებს არ შეუძლია გადასცეს დამუშავების შედეგი მომდევნო მიმღებს და მისი შეწყვეტა შეუძლებელია. მაუწყებლის განზრახვის გავრცელება; ამასთან, შეკვეთილი მაუწყებლობა ემყარება მიმღების მიერ დეკლარირებულ პრიორიტეტს (ანდროიდში დეკლარირებული: intent-filter ელემენტის პრიორიტეტული ატრიბუტი, რაც უფრო დიდია ნომერი, მით უფრო მაღალია პრიორიტეტი, მნიშვნელობის დიაპაზონი: -1000-დან 1000-მდე. ასევე შესაძლებელია დარეკოთ მითითებული IntentFilter ობიექტის setPriority () და მიმღები თავის მხრივ იღებს მაუწყებლობას. მაგალითად, თუ A დონე უფრო მაღალია ვიდრე B და B დონე B უფრო მაღალია ვიდრე C, მაშინ მაუწყებლობა ჯერ გადაეცემა A- ს, შემდეგ B- ს და ბოლოს C- ს. შეუძლია მონაცემთა შენახვა მაუწყებლობაში. როდესაც მაუწყებლობა იგზავნება B- ს, B- ს შეუძლია გადაცემაში მიიღოს A- ს მიერ შენახული მონაცემები.
Context.sendBroadcast ()
რაც იგზავნება არის ჩვეულებრივი მაუწყებლობა და ყველა აბონენტს აქვს შესაძლებლობა მიიღოს და დაამუშაოს იგი.
Context.sendOrowedBroadcast ()
გაგზავნა არის მოწესრიგებული გადაცემა. სისტემა სათითაოდ შეასრულებს მიმღებებს მიმღების მიერ გამოცხადებული პრიორიტეტის შესაბამისად. წინა მიმღებს აქვს მაუწყებლობის შეწყვეტის უფლება (BroadcastReceiver.abortBroadcast ()). თუ მაუწყებლობა წყდება წინა მიმღების მიერ, ამ უკანასკნელს აღარ შეუძლია მაუწყებლობის მიღება. შეკვეთილი მაუწყებლობისთვის, წინა მიმღებს შეუძლია შეინახოს დამუშავების შედეგი სამაუწყებლო ინტენტში და შემდეგ გადასცეს შემდეგ მიმღებს.
მაუწყებლის მიმღები (BroadcastReceiver) გამოიყენება სამაუწყებლო ინტენტის მისაღებად, ხოლო სამაუწყებლო პროგრამის Intent გაგზავნა ხორციელდება Context.sendBroadcast () და Context.sendOruledBroadcast () დარეკვით. ჩვეულებრივ, სამაუწყებლო განზრახვის მიღება შეუძლიათ მრავალი სამაუწყებლო მიმღების მიერ, რომლებიც გამოწერილი არიან ამ განზრახვის. ეს ფუნქცია მსგავსია თემების გაგზავნის მიმღებები JMS– ში. სამაუწყებლო მიმღების მეთოდის განსახორციელებლად შემდეგია:
პირველი ნაბიჯი: განსაზღვრეთ სამაუწყებლო მიმღები, გადაეცით BroadcastReceiver და გადაწერეთ მეთოდი onReceive.
საჯარო კლასის IncomingSMSReceiver აგრძელებს BroadcastReceiver {
@ Override public void onReceive (Contextcontext, Intentintent) {
}
}
ნაბიჯი 2: გამოიწერე მაუწყებლობა ინტერესის განზრახვა, არსებობს გამოწერის ორი მეთოდი:
პირველი ტიპი: გამოიყენეთ კოდი გამოსაწერად (დინამიური გამოწერა)
IntentFilter ფილტრი = newIntentFilter ("android.provider.Telephony.SMS_RECEIVED");
IncomingSMSReceiver მიმღები = newInomingSMSR მიმღები ();
რეგისტრის მიმღები (მიმღები, ფილტრი);
მეორე ტიპი: გამოწერა კვანძი AndroidManifest.xml ფაილში (სტატიკური გამოწერა)
მოდით გავეცნოთ სხვაობას დინამიურ სამაუწყებლო გამოწერასა და სტატიკურ სამაუწყებლო გამოწერას შორის:
სტატიკური გამოწერის მაუწყებლობას ასევე უწოდებენ: რეზიდენტულ მაუწყებლობას. როდესაც თქვენი განცხადება დახურულია, თუ არსებობს სამაუწყებლო შეტყობინება, თქვენს მიერ დაწერილი სამაუწყებლო მიმღებს ასევე შეუძლია მიიღოს იგი. თქვენი რეგისტრაციის მეთოდია AndroidManifast თქვენს პროგრამაში. .xml გამოწერისთვის.
დინამიური სააბონენტო გადაცემა ასევე ეწოდება: არარეზიდენტი მაუწყებლობა. განაცხადის დასრულების შემდეგ, მაუწყებლობა ბუნებრივად გაქრება. მაგალითად, თქვენ იწერთ მაუწყებლობას onCreate ან onResume საქმიანობაში და უნდა გააუქმოთ სამაუწყებლო გამოწერა onDestory ან onPause. წინააღმდეგ შემთხვევაში, გამოცხადდება გამონაკლისი, ამიტომ თქვენი სამაუწყებლო მიმღები იქნება არარეზიდენტი.
აქ კიდევ ერთი დეტალია, ეს არის გამოწერის ორი მეთოდი. მაუწყებლობის გაგზავნისას ყურადღება უნდა მიაქციოთ: ნაგულისხმევი განზრახვის მეთოდი გამოიყენება დინამიური რეგისტრაციისთვის, ამიტომ მაუწყებლობის გაგზავნისას უნდა გამოიყენოთ დაფარული განზრახვა. , წინააღმდეგ შემთხვევაში მაუწყებლის მიმღები ვერ შეძლებს მაუწყებლობის მიღებას. ყურადღება მიაქციეთ ამ საკითხს. როდესაც ხდება სტატიკური გამოწერა, რადგან ეს არის AndroidMainfest.xml– ში გამოწერილი, მაუწყებლობის გაგზავნისას შესაძლებელია გამოვიყენოთ ეკრანი Intent და Implic Intent (რა თქმა უნდა, ეს მხოლოდ ჩვენ მიერ განსაზღვრული სამაუწყებლო მიმღებებისთვისაა), ასე რომ, ყოველი შემთხვევისთვის, ჩვენ ჩვეულებრივ ვიყენებთ მაუწყებლობის გაგზავნის განზრახვა.
მოდით ვნახოთ მაგალითი:
გადახედეთ პროექტის სტრუქტურას:
გადახედეთ სტატიკურ სააბონენტო გადაცემას:
პაკეტი com.broadcast.demo;
android.app.იმპორტის იმპორტი;
იმპორტი android.content.Intent;
იმპორტი android.os.Bundle;
android.view.View- ის იმპორტი
android.view.View.OnClickListener- ის იმპორტი;
android.widget იმპორტი. ღილაკი;
იმპორტი com.example.androidbroadcastdemo.R;
/ **
* სტატიკური გამოწერის მაუწყებლობა
* @ ავტორი weijiang204321
*
*/
საჯარო კლასი StaticRegisterBroadcastActivity ავრცელებს აქტივობას {
@ Override
დაცული სიცარიელე onCreate (პაკეტი შენახულიაInstanceState) {
super.onCreate (შენახული InstanceState);
setContentView (R.layout.activity_main);
ღილაკი btn = (ღილაკი) findViewById (R.id.btn);
დან
btn.setOnClickListener (ახალი OnClickListener () {
@ Override
public void onClick (View v) {
// გამოიყენეთ სტატიკური გზა მაუწყებლობის დარეგისტრირებისთვის, შეგიძლიათ გამოიყენოთ ჩვენების განზრახვა მაუწყებლობის გასაგზავნად
განზრახული მაუწყებლობა = ახალი განზრახვა ("com.broadcast.set.broadcast");
sendBroadcast (მაუწყებლობა, null);
}
დან
});
}
დან
}
გამოიწერე AndroidMainfest.xml:
<მანიფესტი xmlns:android="http://schemas.android.com/apk/res/android"
პაკეტი = "com.example.androidbroadcastdemo"
android: versionCode = "1"
android: versionName = "1.0">
<uses-sdk
android: minSdkVersion = "8"
android: targetSdkVersion = "18" />
<აპლიკაცია
android: allowBackup = "ნამდვილი"
android: icon = "@ drawable / ic_launcher"
android: label = "@ string / app_name"
android: theme = "@ style / AppTheme">
<აქტივობა
android: name = "com.broadcast.demo.StaticRegisterBroadcastActivity"
android: label = "@ string / app_name">
ახლა სხვა შინაარსზე არ ინერვიულოთ, რადგან მოგვიანებით ვისაუბრებთ, აქ მხოლოდ სტატიკური მაუწყებლობის რეგისტრაციას ვამახვილებთ ყურადღებას
მოდით გადავხედოთ მაუწყებლობის მიმღებს:
პაკეტი com.broadcast.receiver;
android.content.BroadcastReceiver- ის იმპორტი;
იმპორტი android.content.Context;
იმპორტი android.content.Intent;
იმპორტი android.util.Log;
/ **
* მაუწყებლის მიმღები
* @ ავტორი weijiang204321
*
*/
UnsortBroadcastReceiver საჯარო კლასის ავრცელებს BroadcastReceiver {
@ Override
public void onReceive (კონტექსტის კონტექსტი, განზრახვა) {
Log.e ("მიზანი_აქცია:", intent.getAction () + "");
}
}
OnReceive მეთოდის ლოგიკა სამაუწყებლო მიმღებში ძალიან მარტივია, რაც ნიშნავს Action- ის შინაარსის დაბეჭდვას.
გაუშვით პროგრამა, შედეგი ძალიან მარტივია, აქ არ არის სურათი.
მოდით გავეცნოთ დინამიურ გამოწერებს:
პაკეტი com.broadcast.demo;
android.app.იმპორტის იმპორტი;
იმპორტი android.content.Intent;
android.content.IntentFilter- ის იმპორტი;
იმპორტი android.os.Bundle;
android.view.View- ის იმპორტი
android.view.View.OnClickListener- ის იმპორტი;
android.widget იმპორტი. ღილაკი;
იმპორტი com.broadcast.receiver.UnSortBroadcastReceiver;
იმპორტი com.example.androidbroadcastdemo.R;
/ **
* გამოიყენეთ დინამიური გზა მაუწყებლობის რეგისტრაციისთვის
* @ ავტორი weijiang204321
*
*/
საჯარო კლასის DynamicRegisterBroadcastActivity ავრცელებს აქტივობას {
დან
საჯარო სტატიკური საბოლოო სტრიქონი NEW_LIFEFORM_DETECTED = "com.dxz.broadcasttest.NEW_LIFEFORM";
დაცულია UnSortBroadcastReceiver მიმღები;
დან
@ Override
დაცული სიცარიელე onCreate (პაკეტი შენახულიაInstanceState) {
super.onCreate (შენახული InstanceState);
setContentView (R.layout.activity_main);
ღილაკი btn0 = (ღილაკი) findViewById (R.id.btn);
btn0.setOnClickListener (ახალი OnClickListener () {
public void onClick (View v) {
// მაუწყებლობის გაგზავნა
Intent it = new Intent (NEW_LIFEFORM_DETECTED);
sendBroadcast (ის);
}
});
}
@ Override
დაცული სიცარიელე Resume () {
super.onResume ();
// რეგისტრაცია მაუწყებლობისთვის
IntentFilter counterActionFilter = ახალი IntentFilter (NEW_LIFEFORM_DETECTED);
მიმღები = ახალი UnSortBroadcastReceiver ();
RegisterReceiver (მიმღები, counterActionFilter);
}
@ Override
დაცული სიცარიელე onPause () {
super.onPause ();
// მაუწყებლობის გაუქმება
რეგისტრაციის გაუქმება მიმღები (მიმღები);
}
}
აქ ჩვენ ვიღებთ ხელმოწერას რეზიუმეში და მაუწყებლობის გაუქმებას ვახდენთ პაუზაზე.
შეცვალეთ დაწყებული აქტივობა DynamicRegisterBroadcastActivity– ში AndroidMainfest.xml– ში. სხვა შინაარსის შეცვლა არ არის საჭირო. გაუშვით პროგრამა და დაბეჭდეთ შედეგი ძალიან მარტივია, ამიტომ სურათს აქ ვერ ვხედავ.
მოდით გავეცნოთ შეკვეთილ მაუწყებლობას და არაორგანიზებულ მაუწყებლობას
ეს უკვე აღვნიშნეთ დასაწყისში, გადავხედოთ უწესრიგო მაუწყებლობას:
პირველ რიგში განვსაზღვრავთ ორი სამაუწყებლო მიმღებს
პირველი სამაუწყებლო მიმღები:
პაკეტი com.broadcast.receiver;
android.content.BroadcastReceiver- ის იმპორტი;
იმპორტი android.content.Context;
იმპორტი android.content.Intent;
იმპორტი android.util.Log;
/ **
* მაუწყებლის მიმღები A
* @ ავტორი weijiang204321
*
*/
საზოგადოებრივი კლასის SortBroadcastReceiverA ავრცელებს BroadcastReceiver {
@ Override
public void onReceive (კონტექსტის კონტექსტი, განზრახვა) {
Log.e ("დემო:", "სამაუწყებლო მიმღები A");
}
}
მეორე სამაუწყებლო მიმღები:
პაკეტი com.broadcast.receiver;
android.content.BroadcastReceiver- ის იმპორტი;
იმპორტი android.content.Context;
იმპორტი android.content.Intent;
იმპორტი android.util.Log;
/ **
* მაუწყებლის მიმღები B
* @ ავტორი weijiang204321
*
*/
საზოგადოებრივი კლასის SortBroadcastReceiverB ავრცელებს BroadcastReceiver {
@ Override
public void onReceive (კონტექსტის კონტექსტი, განზრახვა) {
Log.e ("დემო:", "მაუწყებლობა B");
}
დან
დან
}
გამოიწერეთ გადაცემა AndroidMainfest.xml– ზე
ოპერაციის შედეგი:
გაშვების შედეგი ცოტა უცნაურია. რატომ არის მიმღები B წინა და მიმღები A უკანა მხარეს? მიზეზი არის ის, რომ როდესაც AndroidMainfest.xml– ში ვიღებთ გადაცემას, ჩვენ ვადგენთ android: პრიორიტეტული ატრიბუტის მნიშვნელობას intent– ფილტრში. რაც უფრო დიდი მნიშვნელობა აქვს, მით უფრო მაღალია პრიორიტეტი. მიმღების B პრიორიტეტია 1000, A მიმღების პრიორიტეტი 999, ასე რომ B იღებს მაუწყებლობას ჯერ და შემდეგ A იღებს მას, მაგრამ მიმღებ B- სა და A მიმღებს შორის კავშირი არ არის და ურთიერთქმედება არ შეიძლება რადგან ეს არის მწყობრიდან გამოსული და ასინქრონული, ჩვენ შეგვიძლია გავაკეთოთ ექსპერიმენტი onReceiver მეთოდის კოდის დამატებით B- ში:
abortBroadcast (); // ამ მაუწყებლობის გადაცემის შეწყვეტა
ოპერაციის შედეგი:
ჩვენ შეგვიძლია დავინახოთ სწრაფი შეცდომა. სინამდვილეში, შეწყვეტა აზრი არ აქვს, რადგან A მიმღები კვლავ იღებს მაუწყებლობას.
მოდით შევხედოთ მოწესრიგებულ მაუწყებლობას, საჭიროა კოდის შეცვლა:
პირველი არის მაუწყებლობის გაგზავნისას:
განზრახული მაუწყებლობა = ახალი განზრახვა ("com.broadcast.set.broadcast");
sendOrdedBroadcast (მაუწყებლობა, null);
შემდეგ დაამატეთ მეთოდი B მიმღში მაუწყებლობის შეწყვეტისთვის:
abortBroadcast ();
სხვა კოდის შეცვლა არ არის საჭირო, ოპერაციის შედეგი:
არსებობს მხოლოდ მიმღები B, მიმღები A არ იღებს მაუწყებლობას, რადგან მაუწყებლობა წყდება მიმღების B– ში და შემდგომ მიმღებებს არ შეუძლიათ მიიღონ იგი.
შეცვალეთ კოდი ქვემოთ:
მიმღები B:
პაკეტი com.broadcast.receiver;
android.content.BroadcastReceiver- ის იმპორტი;
იმპორტი android.content.Context;
იმპორტი android.content.Intent;
იმპორტი android.os.Bundle;
იმპორტი android.util.Log;
/ **
* მაუწყებლის მიმღები B
* @ ავტორი weijiang204321
*
*/
საზოგადოებრივი კლასის SortBroadcastReceiverB ავრცელებს BroadcastReceiver {
@ Override
public void onReceive (კონტექსტის კონტექსტი, განზრახვა) {
Log.e ("დემო:", "სამაუწყებლო მიმღები B");
Bundle bundle = new Bundle ();
bundle.putString ("შემდეგი_მიღება", "შემდეგი სამაუწყებლო მიმღები");
setResultExtras (შეკვრა);
}
დან
}
B- ის მაუწყებლობის მიღების შემდეგ, იგი ინახავს გარკვეულ მნიშვნელობას და გადასცემს შემდეგ მიმღებს.
მიმღების A კოდი:
პაკეტი com.broadcast.receive
ჩვენი სხვა პროდუქტი:
