क्या गतिविधि और एक नेस्टेड टुकड़े के बीच संवाद करने के लिए Activity.onAttachFragment या Fragment.onAttach का उपयोग करना बेहतर है?

Question

एंड्रॉइड प्रलेखन से पता चलता है कि किसी गतिविधि से होस्ट किए गए टुकड़े में संवाद करने के लिए, खंड एक कॉलबैक इंटरफेस को परिभाषित कर सकता है और यह आवश्यक है कि मेजबान गतिविधि इसे कार्यान्वित करे। मूल पैटर्न में आपके टुकड़े में onAttach लागू करने और कॉलबैक इंटीफेस में गतिविधि कास्टिंग शामिल है। http://developer.android.com/guide/components/fragments.html#CommunicatingWithActivity देखें।

यहां कुछ प्रारंभिक डेटा के साथ-साथ नेविगेशन कॉलबैक सुनने के लिए एक उदाहरण प्रदान करने का एक उदाहरण दिया गया है।

public class HostActivity extends Activity implements FragmentHost { 
    @Override 
    UiModel getUiModel() { 
    return mUiModel; 
    } 
    @Override 
    FragmentNavListener getNavListener() { 
    return mNavListener; 
    } 
... 
} 

public class HostedFragment extends Fragment { 
    @Override 
    public void onAttach(Activity activity) { 
    super.onAttach(activity); 
    if (activity instanceof FragmentHost) { 
     FragmentHost host = (FragmentHost) activity; 
     setUiModel(host.getUiModel()); 
     setNavListener(host.getFragmentNavListener()); 
    } 
    } 
    ... 
} 

मेजबान गतिविधि में onAttachFragment का उपयोग कर स्पष्ट रूप से टुकड़ा प्रारंभ करने के लिए इस की तुलना करें:

1. यह बनाता है:

   public class HostActivity extends Activity { 
       @Override 
       public void onAttachFragment(Fragment fragment) { 
       super.onAttachFragment(fragment); 
       if (fragment instanceof HostedFragment) { 
        HostedFragment hostedFragment = ((HostFragment) fragment); 
        hostedFragment.setUiModel(mUiModel); 
        hostedFragment.setNavListener(mNavListener); 
       } 
       } 
       ... 
   } 
   

   मेरे लिए

   , यह पहली पैटर्न की तरह लगता है कुछ कमियां विभिन्न गतिविधियों से उपयोग करने के लिए टुकड़ा कठिन है, के बाद से उन सभी गतिविधियों को आवश्यक इंटरफ़ेस को लागू करना होगा। मैं ऐसे मामलों की कल्पना कर सकता हूं जहां एक दिए गए खंड उदाहरण को होस्ट गतिविधि द्वारा पूरी तरह से कॉन्फ़िगर करने की आवश्यकता नहीं है, फिर भी सभी संभावित मेजबान गतिविधियों को मेजबान इंटरफ़ेस को लागू करने की आवश्यकता होगी।

2. यह कोड को इस्तेमाल किए जा रहे पैटर्न से अपरिचित किसी के लिए अनुसरण करना थोड़ा कठिन बनाता है। ऑनफ्रैगमेंट में खंड को शुरू करना एक्टेड का पालन करना आसान लगता है, क्योंकि प्रारंभिक कोड उसी वर्ग में रहता है जो टुकड़ा बनाता है।
3. यूनिट एक पुस्तकालय का उपयोग करते समय onAttach बुला के बाद से Robolectric की तरह कठिन हो जाता है, परीक्षण, आप अब FragmentHost बल्कि सिर्फ बुला से आप में से जो लोग करने के लिए गतिविधि किया है के लिए लागू करना चाहिए onAttach (नई गतिविधि()।

टुकड़ा संचार, क्या पैटर्न आप बेहतर मिल रहा है, और क्यों? वहाँ मेजबान गतिविधि से onAttachFragment उपयोग करने के लिए कमियां हैं?

Answer 1

मैं नहीं कर सकते परीक्षण के संबंध में व्यक्तिगत रूप से बात लेकिन वहाँ टुकड़ा/गतिविधि कॉलबैक इंटरफ़ेस संचार के लिए विकल्प है।

पूर्व के लिए पर्याप्त आप टुकड़े और अपनी गतिविधि को कम करने के लिए एक ईवेंट बस का उपयोग कर सकते हैं। एक उत्कृष्ट घटना बस यहां पाया जा सकता:

Otto - An event Bus by Square

यह सक्रिय रूप से स्क्वायर में कुछ बहुत प्रतिभाशाली इंजीनियरों द्वारा विकसित की जा रही है। आप एंड्रॉइड सपोर्ट लाइब्रेरी में पैक किए गए स्थानीय ब्रॉडकास्ट मैनेजर का भी उपयोग कर सकते हैं।

Android App Anatomy

Answer 2

मैं अपने पिछले परियोजना में Fragment.onAttach(...) पैटर्न का इस्तेमाल किया है:

LocalBroadcastManager

एरिक बर्क वर्ग से एक प्रस्तुति जहां वह दोनों का उल्लेख यहां पाया जा सकता है जो है।मैं दो फायदे देखें:

1. आप जल्दी जांच कर सकते हैं कि होस्टिंग गतिविधि आवश्यक इंटरफ़ेस लागू करता है और एक अपवाद फेंक नहीं तो
2. वहाँ के बाद टुकड़ा अलग कर दिया गया है होस्टिंग संदर्भ के संदर्भ पकड़े का जोखिम कम है

आदेश 2. का लाभ लेने के लिए, आप UiModel और NavListener के लिए संदर्भ की दुकान नहीं करना चाहिए, क्योंकि आप अपने कोड नमूने में करना है। इसके बजाए, जब भी आप इन उदाहरणों से बातचीत करना चाहते हैं, तो आपको ((FragmentHost) getActivity).getNavListener().onNav(this), या वैकल्पिक रूप से ((FragmentHost) getActivity).onNav(this) जैसे कोड का उपयोग करना चाहिए। यदि आप निरंतर कास्टिंग से बचना चाहते हैं, तो आप एक ग्राउंड ग्राउंड दृष्टिकोण के रूप में onDetach(...) में शून्य पर सेट किए गए फ़ील्ड में खंड होस्ट को स्टोर कर सकते हैं।

मैं मानता हूं कि जो गतिविधि बनाता है उससे एक टुकड़ा शुरू करना अधिक सहज लगता है।

यह सब कहकर, मैं अपने वर्तमान प्रोजेक्ट में पूरी तरह से टुकड़े छोड़ने जा रहा हूं। निम्नलिखित पोस्ट मेरे पिछले एक से अच्छी तरह से सीखने वाले पाठों को प्रतिबिंबित करता है: https://corner.squareup.com/2014/10/advocating-against-android-fragments.html