[Android] एंड्रॉइड - मुझे टुकड़े बनाम गतिविधियों और विचारों के कुछ स्पष्टीकरण की आवश्यकता है


Answers

  1. टुकड़ा एक गतिविधि का एक हिस्सा है, जो उस गतिविधि के लिए अपना यूआई योगदान देता है। टुकड़ा एक उप गतिविधि की तरह सोचा जा सकता है। जहां पूरी स्क्रीन के साथ उपयोगकर्ता इंटरैक्ट करता है उसे गतिविधि के रूप में जाना जाता है। एक गतिविधि में कई टुकड़े हो सकते हैं। प्रारूप ज्यादातर गतिविधि का एक उप हिस्सा होते हैं।

  2. एक गतिविधि में स्क्रीन आकार के आधार पर 0 या कई टुकड़े हो सकते हैं। कई गतिविधियों में एक टुकड़े का पुन: उपयोग किया जा सकता है, इसलिए यह गतिविधियों में पुन: प्रयोज्य घटक की तरह कार्य करता है।

  3. एक टुकड़ा स्वतंत्र रूप से अस्तित्व में नहीं हो सकता है। यह हमेशा एक गतिविधि का हिस्सा होना चाहिए। जहां गतिविधि में किसी भी टुकड़े के साथ गतिविधि मौजूद हो सकती है।

Question

एंड्रॉइड एपीआई 11+ में, Google ने Fragment नामक एक नई कक्षा जारी की है।

वीडियो में, Google सुझाव देता है कि जब भी संभव हो ( link1 , link1 ), हमें गतिविधियों की बजाय टुकड़ों का उपयोग करना चाहिए, लेकिन उन्होंने बिल्कुल समझाया नहीं कि क्यों।

टुकड़ों का उद्देश्य और उनमें से कुछ संभावित उपयोग क्या हैं (कुछ यूआई उदाहरणों के अलावा जिन्हें सरल विचार / लेआउट द्वारा आसानी से हासिल किया जा सकता है)?

मेरा सवाल टुकड़ों के बारे में है:

  1. एक टुकड़े का उपयोग करने के उद्देश्य क्या हैं?
  2. गतिविधियों / विचार / लेआउट का उपयोग करने के मुकाबले टुकड़ों का उपयोग करने के फायदे और नुकसान क्या हैं?

बोनस प्रश्न:

  1. क्या आप टुकड़ों के लिए कुछ वाकई दिलचस्प उपयोग कर सकते हैं? जिन चीजों ने Google ने अपने वीडियो में उल्लेख नहीं किया है?
  2. टुकड़ों और उन गतिविधियों के बीच संवाद करने का सबसे अच्छा तरीका क्या है?
  3. जब आप टुकड़ों का उपयोग करते हैं तो याद रखने के लिए सबसे महत्वपूर्ण चीजें क्या हैं? आपके अनुभव से कोई सुझाव और चेतावनियां?



एक टुकड़ा किसी एप्लिकेशन के उपयोगकर्ता इंटरफ़ेस या व्यवहार का एक टुकड़ा है जिसे एक गतिविधि में रखा जा सकता है जो अधिक मॉड्यूलर गतिविधि डिज़ाइन को सक्षम बनाता है। अगर हम कहते हैं कि एक टुकड़ा एक प्रकार की निष्क्रियता है तो यह गलत नहीं होगा।

एक टुकड़े के बारे में महत्वपूर्ण मुद्दे निम्नलिखित हैं:

  1. एक टुकड़े का अपना लेआउट और अपने जीवन के कॉलबैक के साथ अपना व्यवहार होता है।

  2. गतिविधि चल रही है, जबकि आप गतिविधि में टुकड़े जोड़ या निकाल सकते हैं।

  3. मल्टी-फलक यूआई बनाने के लिए आप एक ही गतिविधि में एकाधिक टुकड़े जोड़ सकते हैं।

  4. कई गतिविधियों में एक टुकड़ा का उपयोग किया जा सकता है।

  5. खंड जीवन चक्र अपनी मेजबान गतिविधि के जीवन चक्र से निकटता से संबंधित है।

  6. जब गतिविधि रोका जाता है, तो एसिविटी में उपलब्ध सभी टुकड़े भी बंद कर दिए जाएंगे।

  7. एक टुकड़ा उस व्यवहार को कार्यान्वित कर सकता है जिसमें कोई उपयोगकर्ता इंटरफ़ेस घटक नहीं है।

  8. एपीआई संस्करण 11 के साथ Android 3 (हनीकॉम) में एंड्रॉइड एपीआई में टुकड़े जोड़े गए थे।

अधिक जानकारी के लिए, कृपया आधिकारिक साइट, Fragments




कुछ मामलों में टुकड़े विशेष रूप से उपयोग किए जाते हैं जैसे कि हम अपने सभी पृष्ठों में नेविगेशन ड्रॉवर रखना चाहते हैं। आप जो भी टुकड़ा चाहते हैं उसके साथ एक फ्रेम लेआउट फुला सकते हैं और अभी भी नेविगेशन ड्रॉवर तक पहुंच है।

यदि आपने एक गतिविधि का उपयोग किया था, तो आपको सभी गतिविधियों में दराज रखना होगा जो अनावश्यक कोड बनाता है। यह एक टुकड़े का एक दिलचस्प उपयोग है।

मैं एंड्रॉइड के लिए नया हूं और अभी भी लगता है कि एक टुकड़ा इस तरह सहायक है।




एक टुकड़ा एक गतिविधि के अंदर रहता है।

जबकि एक गतिविधि स्वयं पर रहता है।




एक टुकड़ा किसी गतिविधि में किसी व्यवहार या उपयोगकर्ता इंटरफ़ेस का एक हिस्सा दर्शाता है। आप एक बहु-फलक यूआई बनाने और कई गतिविधियों में एक टुकड़े का पुन: उपयोग करने के लिए एक ही गतिविधि में कई टुकड़ों को जोड़ सकते हैं। आप एक गतिविधि के मॉड्यूलर सेक्शन के रूप में एक टुकड़े के बारे में सोच सकते हैं, जिसकी अपनी जीवनशैली है, अपनी खुद की इनपुट घटनाएं प्राप्त करती है, और गतिविधि चलाने के दौरान आप जो जोड़ या निकाल सकते हैं।

  • आप स्वतंत्र रूप से प्रत्येक टुकड़े में हेरफेर कर सकते हैं, जैसे कि उन्हें जोड़ें या हटाएं। जब आप इस तरह के एक टुकड़े लेनदेन करते हैं, तो आप इसे एक बैक स्टैक में भी जोड़ सकते हैं जो गतिविधि द्वारा प्रबंधित किया जाता है- गतिविधि में प्रत्येक बैक स्टैक प्रविष्टि उस खंडित लेनदेन का रिकॉर्ड है जो हुआ। बैक स्टैक उपयोगकर्ता को बैक बटन दबाकर, एक खंड लेनदेन (पीछे की ओर नेविगेट) करने की अनुमति देता है।

  • जब आप अपने गतिविधि लेआउट के हिस्से के रूप में एक टुकड़ा जोड़ते हैं, तो यह गतिविधि के दृश्य पदानुक्रम के अंदर व्यू ग्रुप में रहता है और खंड अपने स्वयं के दृश्य लेआउट को परिभाषित करता है। आप गतिविधि के लेआउट फ़ाइल में एक तत्व के रूप में, या अपने अनुप्रयोग कोड से मौजूदा व्यू ग्रुप में जोड़कर अपने गतिविधि लेआउट में एक टुकड़ा डाल सकते हैं। हालांकि, गतिविधि लेआउट का एक हिस्सा होने के लिए एक टुकड़े की आवश्यकता नहीं है; आप गतिविधि के लिए एक अदृश्य कार्यकर्ता के रूप में अपने यूआई के बिना एक टुकड़े का भी उपयोग कर सकते हैं।

  • उदाहरण के लिए: यदि आप बिना किसी टुकड़े के नेविगेशन ड्रावर का उपयोग करना चाहते थे तो नेविगेशन ड्रावर इंस्टेंस को एक ही गतिविधि में रखना सबसे अच्छा होगा और जब आप नेविगेशन ड्रावर में आइटमों का चयन करके ऐप पर नेविगेट करेंगे तो उन सभी क्रियाकलापों को लागू नहीं किया जाना चाहिए नेविगेशन ड्रावर लेकिन इसके बजाय नेविगेशन ड्रावर को लागू करने वाले "मुख्य" / एकल गतिविधि पर नेविगेट करने के लिए बैक बटन को कार्यान्वित करना चाहिए।

    नोट: यदि आप कई गतिविधियों में नेविगेशन ड्रावर को कार्यान्वित करना चाहते हैं तो आपको इसे प्रदर्शित करने की इच्छा रखने वाली प्रत्येक गतिविधि में नेविगेशन ड्रावर का एक नया उदाहरण बनाना होगा।

    मुझे लगता है कि यह एक नुकसान बनाम बनाम टुकड़े का उपयोग कर रहा है, जबकि यदि आप एक टुकड़े का उपयोग करते हैं तो आपको दराज के कई उदाहरणों की आवश्यकता नहीं होगी, आपको केवल एक की आवश्यकता होगी।

    क्रियाकलापों के बजाय टुकड़ों के साथ दराज

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

  • अपनी गतिविधि में खंड के बीच संवाद करें : एक फ्रैगमेंट को अपनी गतिविधि तक संवाद करने की अनुमति देने के लिए, आप फ्रैगमेंट क्लास में एक इंटरफ़ेस परिभाषित कर सकते हैं और इसे गतिविधि के भीतर कार्यान्वित कर सकते हैं। फ्रैगमेंट इंटरफ़ेस कार्यान्वयन को इसके ऑनएट () जीवन चक्र विधि के दौरान कैप्चर कर सकता है और फिर गतिविधि के साथ संवाद करने के लिए इंटरफ़ेस विधियों को कॉल करें।

    public class YourFragment extends ListFragment {
    OnSelectedListener mCallback;
    
    // Container Activity must implement this interface
    public interface OnSelectedListener {
        public void onItemSelected(int position);
    }
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.your_view, container, false);
    }
    
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
    
        // This makes sure that the container activity has implemented
        // the callback interface. If not, it throws an exception
        try {
            mCallback = (OnSelectedListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString()
                    + " must implement OnSelectedListener");
        }
    }
    
    }...
    

अब खंड ऑनइलेक्टेड लिस्टनर इंटरफ़ेस के mCallback इंस्टेंस का उपयोग करके ऑनइटम चयन () इंटरफ़ेस (या इंटरफ़ेस में अन्य विधियों) को कॉल करके गतिविधि को संदेश वितरित कर सकता है।

public static class MainActivity extends Activity
        implements YourFragment.OnSelectedListener{
    ...

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_activity);
    }

    public void onItemSelected(int position) {
        // The user selected the headline of an article from the YourFragment
        // Do something here to display that article

        YourFragment yourFrag = (YourFragment)
                getSupportFragmentManager().findFragmentById(R.id.your_fragment);

        if (yourFrag != null) {
            // If your frag is available, we're in two-pane layout...

            // Call a method in the YourFragment to update its content
            yourFrag.updateView(position);
        } else {
            // Otherwise, we're in the one-pane layout and must swap frags...

            // Create fragment and give it an argument for the selected item
            YourFragment newFragment = new YourFragment();
            Bundle args = new Bundle();
            args.putInt(YourFragment.ARG_POSITION, position);
            newFragment.setArguments(args);

            FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

            // Replace whatever is in the fragment_container view with this fragment,
            // and add the transaction to the back stack so the user can navigate back
            transaction.replace(R.id.fragment_container, newFragment);
            transaction.addToBackStack(null);

            // Commit the transaction
            transaction.commit();
        }
    }
}





Links