धागे को सिंक्रनाइज़ करने का दूसरा तरीका

यह विषय इंटेंट , ब्रॉडकास्टसीवर और हैंडलर का उपयोग करके धाराओं को सिंक्रनाइज़ करने के एक और तरीके पर चर्चा करता है। यह विधि बहुत बोझिल लग सकती है, लेकिन फिर भी काफी सुविधाजनक है, खासकर अगर एप्लिकेशन बहुत अधिक अतुल्यकालिक धागे का उपयोग करता है। उदाहरण के लिए, यदि कोई सेवा कार्यान्वित की जा रही है जो पृष्ठभूमि में एक वेब सेवा के साथ संचार करती है। एक अन्य उदाहरण एक एप्लिकेशन है जिसे एक साथ कई प्लेटफार्मों पर पोर्ट किया गया है, और अधिकांश एपीआई वर्क कोड एंड्रॉइड, जे 2 एमई और विंडोज फोन 7 पर साझा किए जा सकते हैं।

कार्य योजना

1. हम इरादों के नाम के साथ एक स्थिर वर्ग तैयार कर रहे हैं।
   
2. हम इंटेंस भेजने के लिए एप्लिकेशन उत्तराधिकारी वर्ग में तरीके बनाते हैं।
   
3. धागे से हम घटना के इरादे भेजते हैं।
   
4. हम ब्रॉडकास्टर का उपयोग करते हुए गतिविधि में इंटेंट्स को पकड़ते हैं।
   
5. हम हैंडलर को इवेंट पास करते हैं और उन्हें प्रोसेस करते हैं।
   

इंटेंट

इरादे निष्पादन के लिए संचालन के सार वर्णन हैं (प्रलेखन के अनुसार)। आवेदन में, एक स्थिर वर्ग में कार्यों और इरादे मापदंडों के साथ सभी स्थिरांक के भंडारण को व्यवस्थित करना सुविधाजनक है। हमारे मामले में, उदाहरण के लिए, हम दो क्रियाओं का उपयोग करेंगे - सूची पृष्ठ लोड किया गया है और चित्र लोड किया गया है।

public final class Intents { //     public final static String LIST_PAGE_RECEIVED = "com.olsoft.list.page.received"; //   public final static String IMAGE_RECEIVED = "com.olsoft.image.received "; … } 

न्यूज़लैटर के इरादे

आवेदन विधियों के माध्यम से भेजा जा सकता है: यह किसी भी वर्ग से सुलभ है, संदर्भ के लिए लिंक को स्थानांतरित करना और संग्रहीत करना आवश्यक नहीं है।

 public class SampleApplication extends Application { private static SampleApplication mInstance; @Override public void onCreate() { super.onCreate(); mInstance = this; … } /*** *    */ public static SampleApplication getInstance() { return mInstance; } /*** *      * * @param action –  */ public void sendBroadcastIntent(String action) { final Intent intent = new Intent(action); sendBroadcast(intent); } /*** * ,     */ public static void notifyListPageLoaded() { getInstance().sendBroadcast(new Intent(Intents. LIST_PAGE_RECEIVED)); } /*** * ,    */ public static void notifyImageLoaded() { getInstance().sendBroadcast(new Intent(Intents.IMAGE_RECEIVED)); } … } 

इसलिए, इंटेंस भेजना बहुत सरल लगता है:

 @Override public void OnDownloadComplete(byte[] data) { … parseData(data); SampleApplication.notifyListPageLoaded(); … } @Override public void OnDownloadComplete(byte[] data) { … mImage = BitmapFactory.decodeByteArray(data, 0, data.length); SampleApplication.notifyListPageLoaded(); … } 

यदि आवश्यक हो, तो आप इरादे के लिए अतिरिक्त पैरामीटर स्थानांतरित कर सकते हैं, उदाहरण के लिए, चित्र आईडी। ऐसा करने के लिए, putExtra विधि का उपयोग करें।

अंतर्द्वंद्वों का अवरोध

गतिविधि में, हम ब्रॉडकास्टर्स के एक अनाम उदाहरण का उपयोग करके इंटेंट्स को कैप्चर करते हैं। हम इसे उस समय स्थापित करते हैं जब गतिविधि अग्रभूमि में चली जाती है और जब गतिविधि स्क्रीन से बाहर निकलती है तो इसे हटा देती है।

 /*** *       */ @Override protected void onResume() { super.onResume(); IntentFilter f = new IntentFilter(); f.addAction(Intents.LIST_PAGE_RECEIVED); f.addAction(Intents.IMAGE_RECEIVED); registerReceiver(mNotificationReceiver, f); … } /*** *       */ @Override protected void onPause() { unregisterReceiver(mNotificationReceiver); super.onPause(); } /*** *  .        UI  */ private BroadcastReceiver mNotificationReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (Intents.IMAGE_RECEIVED.equalsIgnoreCase(action)) { mHandler.removeMessages(MESSAGE_IMAGE_LOADED); mHandler.sendEmptyMessageDelayed(MESSAGE_IMAGE_LOADED, 250); } else if (Intents. LIST_PAGE_RECEIVED.equalsIgnoreCase(action)) { mHandler.sendEmptyMessage(MESSAGE_NEXT_PAGE); } } }; 

हम घटनाओं को स्वयं एक अनाम हैंडलर के पास भेजते हैं, क्योंकि गतिविधि में इवेंट प्रोसेसिंग अक्सर स्क्रीन पर अपडेट होने वाले घटकों से जुड़ी होती है और UI थ्रेड में निष्पादन की आवश्यकता होती है। इस समाधान का एक अतिरिक्त प्लस यह है कि आप घटकों को देरी से अपडेट कर सकते हैं और कुछ घटनाओं को काट सकते हैं ताकि स्क्रीन पर झिलमिलाहट न पैदा हो, उदाहरण के लिए, यदि प्रत्येक सूची आइटम में एक तस्वीर होती है जो एक अलग थ्रेड में भरी हुई होती है ( रिमूवल पर ध्यान दें और SendEmptyMessageDelayed मेथड )।

 private final static int MESSAGE_NEXT_PAGE = 1; private final static int MESSAGE_IMAGE_LOADED = 2; /** *  .  ,      UI thread */ private Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_NEXT_PAGE: mAdapter.notifyDataSetChanged(); break; case MESSAGE_IMAGE_LOADED: mAdapter.notifyDataSetChanged(); break; default: break; } super.handleMessage(msg); } }; 

निष्कर्ष

यहां दी गई विधि बल्कि बोझिल लग रही है, लेकिन अगर आप इस बात को ध्यान में रखते हैं कि ज्यादातर गतिविधियों में थ्रेड्स से घटनाओं को रोकना आवश्यक हो सकता है, तो इस कार्यक्षमता को आधार गतिविधि में स्थानांतरित करना और बाकी को इस बेस क्लास से विरासत में लेना उचित है। कोड स्वयं ग्रहण स्निपेट में दर्ज किया जाना चाहिए और हर बार दर्ज नहीं किया जाना चाहिए।