एंड्रॉइड में गतिविधि से लेकर टुकड़े तक का डेटा भेजें

Question

मेरी दो कक्षाएं हैं। पहला गतिविधि है, दूसरा एक टुकड़ा है जहां मेरे पास कुछ है EditText। गतिविधि में मेरे पास async-task के साथ एक उपवर्ग है और विधि में doInBackgroundमुझे कुछ परिणाम मिलता है, जिसे मैं चर में सहेजता हूं। मैं इस खंड के लिए उपवर्ग "मेरी गतिविधि" से इस चर को कैसे भेज सकता हूं?

Answer 1

गतिविधि से आप इरादे के साथ डेटा भेजते हैं:

Bundle bundle = new Bundle();
bundle.putString("edttext", "From Activity");
// set Fragmentclass Arguments
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

और Fragment onCreateView विधि में:

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {
    String strtext = getArguments().getString("edttext");    
    return inflater.inflate(R.layout.fragment, container, false);
}

Comments

क्या आप टुकड़े करने के लिए एक वस्तु पारित कर सकते हैं?

— यमन

हम्म मुझे कॉल करते समय NullPointerException मिलती हैgetArguments().getString(key)

— निमा जी

NullPointerException "स्ट्रिंग स्ट्रैटेक्ट सेटअर्गुमेंट्स ()। GetString (" edtxt ");"

— जोर्जेस

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

— बालचंद्रम

@Aznix। टुकड़े के लिए कंस्ट्रक्टर बनाने की अनुशंसा नहीं की जाती है।

— आजम

Answer 2

इसके अलावा, आप गतिविधि डेटा को टुकड़े से एक्सेस कर सकते हैं:

गतिविधि:

public class MyActivity extends Activity {

    private String myString = "hello";

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

    public String getMyData() {
        return myString;
    }
}

टुकड़ा:

public class MyFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        MyActivity activity = (MyActivity) getActivity();
        String myDataFromActivity = activity.getMyData();
        return view;
    }
}

Comments

यह समाधान आपकी गतिविधि और फ्रैगमेंट के बीच तंग युग्मन को एकीकृत करता है, बेहतर है कि Bundleजानकारी पास करने के लिए कक्षा का उपयोग करें । वैकल्पिक रूप से आप getMyData()एक इंटरफ़ेस से विरासत में मिली और कार्यान्वित की गई विधि को बना सकते हैं और Fragmentजाँच सकते हैं कि getActivity किसी instanceofइंटरफ़ेस को देता है या नहीं onAttach()।

— रूडी करशॉ

यह समाधान मेरे लिए सबसे अच्छा है। इसके अलावा अगर myString सार्वजनिक हो, तो आपने getMyData () विधि की घोषणा नहीं की है

— Burak

वर्तमान स्वीकार किए जाते हैं उत्तर अशक्त सूचक रिटर्न रिटर्न। यह स्वीकृत उत्तर होना चाहिए

— रिचमंड

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

— मार्टिन मार्कोसिनी

Answer 3

मुझे यहाँ ढेर सारे उत्तर मिले @ stackoverflow.com लेकिन निश्चित रूप से यह सही उत्तर है:

"एंड्रॉइड में गतिविधि से टुकड़ा तक डेटा भेजना"।

गतिविधि:

        Bundle bundle = new Bundle();
        String myMessage = "Stackoverflow is cool!";
        bundle.putString("message", myMessage );
        FragmentClass fragInfo = new FragmentClass();
        fragInfo.setArguments(bundle);
        transaction.replace(R.id.fragment_single, fragInfo);
        transaction.commit();

टुकड़ा:

टुकड़े में मूल्य पढ़ना

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        Bundle bundle = this.getArguments();
        String myValue = bundle.getString("message");
        ...
        ...
        ...
        }

या केवल

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        String myValue = this.getArguments().getString("message");
        ...
        ...
        ...
        }

Comments

मुझे लगता है कि एक सूची दृश्य में onQueryTextSubmit- खोज-परिणामों को अपडेट करने के लिए यह सबसे अच्छा तरीका नहीं है, जो कि एक Fragment के अंदर नेस्टेड है (यदि किसी व्यक्ति ने तेजी से टाइप किया है, तो वह दो बार आर्ग को दूसरी बार भेजेगा)?

— मार्टिन फ़फ़र

स्ट्रिंग या इंट की वस्तु के बारे में क्या?

— डारियो

@Jorgesys इस समाधान के बारे में क्या? developer.android.com/training/basics/fragments/…

— yozhik

Answer 4

यह उत्तर बहुत देर हो सकती है। लेकिन यह भविष्य के पाठकों के लिए उपयोगी होगा।

मेरे पास कुछ मापदंड हैं। मैंने इरादे से फाइल लेने के लिए कोड किया है। और चयनित फ़ाइल को आगे की प्रक्रिया के लिए विशेष खंड में पारित किया जाना है। मेरे पास फ़ाइल उठाने की कार्यक्षमता वाले कई टुकड़े हैं। समय पर, हर बार हालत की जाँच करने और टुकड़ा पाने और मूल्य पारित करने के लिए काफी घृणित है। इसलिए, मैंने इंटरफ़ेस का उपयोग करके मूल्य को पारित करने का निर्णय लिया है।

चरण 1: मुख्य गतिविधि पर इंटरफ़ेस बनाएँ।

   public interface SelectedBundle {
    void onBundleSelect(Bundle bundle);
   }

चरण 2: समान गतिविधि पर चयनित बंडले संदर्भ बनाएँ

   SelectedBundle selectedBundle;

चरण 3: समान गतिविधि में विधि बनाएँ

   public void setOnBundleSelected(SelectedBundle selectedBundle) {
       this.selectedBundle = selectedBundle;
   }

चरण 4: चयनित बंडले संदर्भ को आरम्भ करने की आवश्यकता है जो कि सभी विखंडन के लिए फाइलपिकर कार्यक्षमता की आवश्यकता है। आप इस कोड को एक विखंडन onCreateView(..)विधि पर रखें।

    ((MainActivity)getActivity()).setOnBundleSelected(new MainActivity.SelectedBundle() {
          @Override
         public void onBundleSelect(Bundle bundle) {
            updateList(bundle);
        }
     });

चरण 5: मेरा मामला, मुझे होम एक्टिविटी से लेकर टुकड़े तक उरी पारित करने की आवश्यकता है। तो, मैं onActivityResult विधि पर इस कार्यक्षमता का उपयोग किया।

onActivityResult MainActivity से, इंटरफ़ेस का उपयोग करके टुकड़ों को मान पास करें।

नोट: आपका मामला अलग हो सकता है। आप इसे अपने HomeActivity से किसी भी स्थान से कॉल कर सकते हैं।

 @Override
 protected void onActivityResult(int requestCode, int resultCode, Intent  data) {
       selectedBundle.onBundleSelect(bundle);
  }

बस इतना ही। FragmentClass पर आपके द्वारा आवश्यक प्रत्येक टुकड़े को लागू करें। तुम महान हो। तुमने कर दिया। वाह...

Answer 5

Fragments (F) का उपयोग करने का मूल विचार Android अनुप्रयोगों में पुन: प्रयोज्य आत्म निरंतर UI घटक बनाना है। ये फ़्रैगमेंट गतिविधियों में निहित हैं और ए -> एफ और एफए से संचार पथ के तरीके बनाने के सामान्य (सबसे अच्छे) तरीके हैं, यह एक गतिविधि के माध्यम से एफएफ के बीच संवाद करना होगा क्योंकि तब केवल फ्रैगमेंट डिकॉउंड और सेल्फिंग हो जाते हैं।

इसलिए A -> F से डेटा पास करना उसी तरह है जो ρяєρ fromя K. द्वारा समझाया गया है। उस उत्तर के अलावा, किसी गतिविधि के अंदर फ़्रैग्मेन्ट के निर्माण के बाद, हम फ़्रैगमेंट में कॉल करने के तरीकों के डेटा को भी पास कर सकते हैं।

उदाहरण के लिए:

    ArticleFragment articleFrag = (ArticleFragment)
                    getSupportFragmentManager().findFragmentById(R.id.article_fragment);
    articleFrag.updateArticleView(position);

Comments

सबूत: developer.android.com/training/basics/fragments/…

— yozhik

Answer 6

सबसे अच्छा और सुविधाजनक दृष्टिकोण टुकड़ा उदाहरण कह रहा है और उस समय डेटा भेजें। डिफ़ॉल्ट रूप से प्रत्येक टुकड़े में आवृत्ति विधि होती है

उदाहरण के लिए: यदि आपके टुकड़े का नाम MyFragment है

तो आप इस तरह की गतिविधि से अपने टुकड़े को बुलाएंगे:

getSupportFragmentManager().beginTransaction().add(R.id.container, MyFragment.newInstance("data1","data2"),"MyFragment").commit();

* R.id.container मेरे FrameLayout की एक आईडी है

इसलिए MyFragment.newInstance ("data1", "data2") में आप डेटा को टुकड़े में भेज सकते हैं और आपके टुकड़े में आपको MyFragment newInstance (स्ट्रिंग param1, String param2) में यह डेटा मिलता है।

public static MyFragment newInstance(String param1, String param2) {
        MyFragment fragment = new MyFragment();
        Bundle args = new Bundle();
        args.putString(ARG_PARAM1, param1);
        args.putString(ARG_PARAM2, param2);
        fragment.setArguments(args);
        return fragment;
    }

और फिर टुकड़ा के onCreate विधि में आपको डेटा मिलेगा:

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
    }

इसलिए अब mParam1 में data1 और mParam2 में data2 है

अब आप अपने टुकड़े में इस mParam1 और mParam2 का उपयोग कर सकते हैं ।

Comments

यहाँ R.id.container क्या है? क्या आपका मतलब है R.id.container_current इसका एक अंतर मूल्य है।

— शौर्य उप्पल

@ s * R.id.container मेरे फ्रेमलैट की एक आईडी है

— Pre_hacker

अब तक का सबसे अच्छा स्पष्टीकरण मैंने कभी भी फ्रैग्मेंट मैनेजर का उपयोग करके डेटा को जोड़ने / बदलने के स्थान पर पाया है। मणि की तरह काम करता है! धन्यवाद!

— सैम

R.id.nav_host_fragment के बजाय R.id.container

— Bahaa Hany

Answer 7

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

यदि आप जावा क्लास के भीतर उस खंड का उपयोग करते हैं जहां आपके पास वह डेटा है जिसे आप पास करना चाहते हैं, तो आप डेटा पास करने के लिए पहला उत्तर लागू कर सकते हैं:

Bundle bundle = new Bundle();
bundle.putString("edttext", "From Activity");
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

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

भले ही आप अपने FragmentClasses के साथ डिफ़ॉल्ट प्लेसहोल्डरफ़्रेग्मेंट को प्रतिस्थापित करते हैं, और यह भी काम नहीं करेगा, भले ही आप GetItem के लिए एक स्विच जोड़कर नई स्थिति के लिए FragmentPagerAdapter को ठीक करें () और GetPitTitle के लिए एक और स्विच () (जैसा कि यहां दिखाया गया है )

चेतावनी: ऊपर उल्लिखित क्लिप में कोड त्रुटियाँ हैं, जिन्हें मैं बाद में यहाँ समझाता हूँ, लेकिन यह देखने के लिए उपयोगी है कि आप टैब्लेट के टुकड़ों के लिए डिफ़ॉल्ट कोड से संपादन योग्य कोड तक कैसे जाते हैं)! यदि आप उस क्लिप से जावा क्लासेस और xml फ़ाइलों पर विचार करते हैं, तो मेरे जवाब के बाकी हिस्से को और अधिक समझ में आता है (शुरुआती परिदृश्य से वर्जित अंशों के पहले उपयोग के लिए प्रतिनिधि)।

इस पृष्ठ से सबसे अधिक उत्क्रमित उत्तर काम नहीं करेगा, यह है कि टैब किए गए अंशों के लिए डिफ़ॉल्ट कोड में, टुकड़ों का उपयोग किसी अन्य जावा वर्ग में किया जाता है: FragmentPagerAdapter!

इसलिए, डेटा भेजने के लिए, आपको उत्तर संख्या 2 का उपयोग करके MotherActivity में एक बंडल बनाने और FragmentPagerAdapter में इसे पास करने का प्रलोभन दिया जाता है।

केवल वही गलत है। ( संभवतः आप इसे ऐसा कर सकते थे, लेकिन यह सिर्फ एक जटिलता है जिसकी वास्तव में आवश्यकता नहीं है )।

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

 public static class Tab1 extends Fragment {

    public Tab1() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.your_layout_name_for_fragment_1, container, false);
        return rootView;
    }
}.

इसलिए, मदरटिविटी से डेटा को इस तरह के फ्रैगमेंट में पास करने के लिए आपको अपनी माँ की गतिविधि के तहत निजी स्ट्रिंग्स / बंडलों को बनाने की आवश्यकता होगी - जिसे आप उस डेटा से भर सकते हैं जिसे आप टुकड़ों में पास करना चाहते हैं, और उनके माध्यम से पास करना चाहते हैं। onCreate के बाद बनाई गई विधि (यहाँ getMyData () कहा जाता है)।

public class MotherActivity extends Activity {

    private String out;
    private Bundle results;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_mother_activity);

       // for example get a value from the previous activity
        Intent intent = getIntent();
        out = intent.getExtras().getString("Key");

    }

    public Bundle getMyData() {
        Bundle hm = new Bundle();
        hm.putString("val1",out);
        return hm;
    }
}

और फिर टुकड़ा वर्ग में, आप getMyData का उपयोग करें:

public static class Tab1 extends Fragment {
        /**
         * The fragment argument representing the section number for this
         * fragment.
         */
        public Tab1() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            View rootView = inflater.inflate(R.layout.your_layout_name_for_fragment_1, container, false);
            TextView output = (TextView)rootView.findViewById(R.id.your_id_for_a_text_view_within_the_layout);

            MotherActivity activity = (MotherActivity)getActivity();

            Bundle results = activity.getMyData();
            String value1 = results.getString("val1");

            output.setText(value1);
            return rootView;
        }
    }

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

शुरुआती लोगों के लिए मेरी सलाह छोटे कदमों पर ध्यान केंद्रित करना है। सबसे पहले, किसी भी डेटा को पारित किए बिना, एक बहुत ही सरल टैब्ड गतिविधि को खोलने का अपना इरादा प्राप्त करें। क्या यह काम करता है? क्या यह आपके द्वारा अपेक्षित टैब को खोलता है? यदि नहीं, तो क्यों?

उससे शुरू करें, और इस क्लिप में प्रस्तुत किए गए समाधानों को लागू करके देखें कि क्या गायब है। उस विशेष क्लिप के लिए, mainactivity.xml कभी नहीं दिखाया गया है। वह निश्चित रूप से आपको भ्रमित करेगा। लेकिन अगर आप ध्यान देते हैं, तो आप देखेंगे कि उदाहरण के लिए संदर्भ (उपकरण: संदर्भ) xml टुकड़ा फ़ाइलों में गलत है। प्रत्येक टुकड़ा XML को सही टुकड़ा वर्ग (या विभाजक का उपयोग करके उपवर्ग) को इंगित करने की आवश्यकता होती है।

आप यह भी देखेंगे कि मुख्य गतिविधि जावा वर्ग में आपको tabLayout.setupWithViewPager (mViewPager) जोड़ने की आवश्यकता है - लाइन TabLayout tabLayout = (TabLayout) findViewyyId (R.id.tabs) के ठीक बाद; इस पंक्ति के बिना, आपका दृश्य वास्तव में टुकड़े की XML फ़ाइलों से जुड़ा नहीं है, लेकिन यह मुख्य गतिविधि का केवल xml फ़ाइल दिखाता है।

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

कृपया ध्यान दें कि पिछले 3 पैराग्राफ में मैं वीडियो के बारे में बात करता हूं! इसलिए जब मैं मुख्य गतिविधि XML कहता हूं, तो यह वीडियो में मुख्य गतिविधि XML है, जो आपकी स्थिति में MotherActivity XML फ़ाइल है।

Answer 8

यदि आप एसिंक्स कार्य में खंड (ठोस उपवर्ग) के संदर्भ को पास करते हैं, तो आप सीधे खंड तक पहुंच सकते हैं।

अंश के सन्दर्भ को एस्सिंक कार्य में पास करने के कुछ तरीके:

• यदि आपका async कार्य पूरी तरह से विकसित वर्ग ( class FooTask extends AsyncTask) है, तो अपने टुकड़े को कंस्ट्रक्टर में पास करें।
• यदि आपका async कार्य एक आंतरिक वर्ग है, तो async कार्य परिभाषित किए गए दायरे में, या बाहरी वर्ग के क्षेत्र के रूप में एक अंतिम Fragment चर घोषित करें। आप आंतरिक वर्ग से उस तक पहुंच बना पाएंगे।

Comments

आपका उत्तर मेरे लिए काफी कानूनी है, क्या आप कुछ और उदाहरण देकर कोड का विस्तार कर सकते हैं?

— लियोन आर्मस्ट्रांग

Answer 9

कभी-कभी आप अपनी गतिविधि में इरादे प्राप्त कर सकते हैं और आपको अपने काम के टुकड़े को जानकारी पारित करने की आवश्यकता है।
दिए गए उत्तर ठीक हैं यदि आपको टुकड़ा शुरू करने की आवश्यकता है लेकिन अगर यह अभी भी काम कर रहा है, setArguments()तो बहुत उपयोगी नहीं है।
एक और समस्या तब होती है जब पारित जानकारी आपके यूआई के साथ बातचीत करने का कारण होगी। उस स्थिति में आप ऐसा कुछ नहीं कह सकते myfragment.passData()क्योंकि Android जल्दी से बताएगा कि केवल थ्रेड जिसने दृश्य बनाया है वह आपके साथ सहभागिता कर सकता है।

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

आपके टुकड़े में onCreate():

protected DataReceiver dataReceiver;
public static final String REC_DATA = "REC_DATA";

@Override
public void onCreate(Bundle savedInstanceState) {


    data Receiver = new DataReceiver();
    intentFilter = new IntentFilter(REC_DATA);

    getActivity().registerReceiver(dataReceiver, intentFilter);
}

private class DataReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        int data= intent.getIntExtra("data", -1);

        // Do anything including interact with your UI
    }
}

आप गतिविधि में:

// somewhere
Intent retIntent = new Intent(RE_DATA);
retIntent.putExtra("data", myData);
sendBroadcast(retIntent);

Answer 10

बहुत पुरानी पोस्ट, फिर भी मैंने थोड़ा स्पष्टीकरण जोड़ने का साहस किया जो मेरे लिए मददगार रहा होगा।

तकनीकी रूप से आप किसी भी प्रकार के सदस्यों को गतिविधि से अलग कर सकते हैं।
तो बंडल क्यों?
कारण बहुत सरल है - बंडल संभाल करने के लिए एकसमान तरीका प्रदान करता है:
- टुकड़ा बनाना / खोलना
- पुन: संयोजन (स्क्रीन रोटेशन) - बस ऑनस्टैव इनस्टांसस्टेट () में आउटस्टेट के लिए प्रारंभिक / अद्यतन बंडल जोड़ें
- पृष्ठभूमि में एकत्र किए गए कचरे के बाद ऐप की बहाली पुनर्संरचना के साथ)।

आप (यदि आप प्रयोगों को पसंद करते हैं) सरल स्थितियों में एक वैकल्पिक हल बना सकते हैं, लेकिन बंडल-एप्रोच सिर्फ एक टुकड़े और एक बैकस्टैक पर एक हजार के बीच अंतर नहीं देखता है - यह सरल और सीधा रहता है।
इसीलिए @Elenasys का जवाब सबसे सुरुचिपूर्ण और सार्वभौमिक समाधान है।
और इसीलिए @Martin द्वारा दिए गए जवाब में नुकसान है

Answer 11

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

FragmentClass fragmentClass = new FragmentClass();
fragmentClass.setMyList(mylist);
fragmentClass.setMyString(myString);
fragmentClass.setMyMap(myMap);

और इन आंकड़ों को कक्षा से आसानी से प्राप्त कर सकते हैं।

Comments

डेटा को खंड से खंड में कैसे जाने के लिए जैसे stackoverflow.com/questions/32953477/pass-data-to-fragment

— हू

यह बहुत सुविधाजनक नहीं है जब आप अन्य के साथ गुजर रहे हैं, पहले से अतिरिक्त है

— जेरार्ड

यदि आपको उस डेटा को अपने खंड में किसी फ़ील्ड में सेट करने की आवश्यकता है, और यह अभी तक दिखाई नहीं दे रहा है (आरंभिक) तो आपको एनपीई मिलेगा।

— योझिक

developer.android.com/training/basics/fragments/…

— yozhik

मैंने 3 साल पहले एंड्रॉइड की संभावना के साथ काम करना बंद कर दिया था, इन दिनों ये चीजें खराब हो सकती हैं।

— ssi-aik

Answer 12

से Activityआप बंडल के साथ डेटा भेजें:

Bundle bundle = new Bundle();
bundle.putString("data", "Data you want to send");

// Your fragment
MyFragment obj = new MyFragment();
obj.setArguments(bundle);

और FragmentonCreateView पद्धति में डेटा प्राप्त करें:

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) 
{
    String data = getArguments().getString("data");// data which sent from activity  
    return inflater.inflate(R.layout.myfragment, container, false);
}

Answer 13

एक तो activityएक करने की जरूरत fragmentआरंभीकरण के बाद कोई कार्रवाई करने, सबसे आसान तरीका होने से है activityपर वापस लाने fragmentउदाहरण। में fragment, एक विधि जोड़ें:

public class DemoFragment extends Fragment {
  public void doSomething(String param) {
      // do something in fragment
  }
}

और फिर में activity, प्रबंधक fragmentका उपयोग करने के लिए पहुँच प्राप्त fragmentकरें और कॉल करें method:

public class MainActivity extends FragmentActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DemoFragment fragmentDemo = (DemoFragment) 
            getSupportFragmentManager().findFragmentById(R.id.fragmentDemo);
        fragmentDemo.doSomething("some param");
    }
}

और फिर इसे लागू करके activityसीधे संवाद कर सकते हैं ।fragmentmethod

Comments

यह वास्तव में अच्छा है, इस अर्थ में कि आप onCreateViewखंड में विधि में प्रवेश नहीं करना चाहते हैं। वास्तव में उपयोगी था

— यंग एमिल

Answer 14

गतिविधि और टुकड़े के बीच संवाद करने के लिए निम्नलिखित इंटरफ़ेस का उपयोग करें

public interface BundleListener {
    void update(Bundle bundle);
    Bundle getBundle();
}

या इंटरफ़ेस का उपयोग करके दो तरह से संचार के लिए इस सामान्य श्रोता का उपयोग करें

 /**
 * Created by Qamar4P on 10/11/2017.
 */
public interface GenericConnector<T,E> {
    T getData();
    void updateData(E data);
    void connect(GenericConnector<T,E> connector);
}

टुकड़ा दिखाने की विधि

public static void show(AppCompatActivity activity) {
        CustomValueDialogFragment dialog = new CustomValueDialogFragment();
        dialog.connector = (GenericConnector) activity;
        dialog.show(activity.getSupportFragmentManager(),"CustomValueDialogFragment");
    }

आप करने के लिए अपने संदर्भ डाल सकता GenericConnectorमें onAttach(Context)भी

आपकी गतिविधि में

CustomValueDialogFragment.show(this);

आपके टुकड़े में

...
@Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        connector.connect(new GenericConnector() {
            @Override
            public Object getData() {
                return null;
            }

            @Override
            public void updateData(Object data) {

            }

            @Override
            public void connect(GenericConnector connector) {

            }
        });
    }
...
    public static void show(AppCompatActivity activity, GenericConnector connector) {
            CustomValueDialogFragment dialog = new CustomValueDialogFragment();
            dialog.connector = connector;
            dialog.show(activity.getSupportFragmentManager(),"CustomValueDialogFragment");
        }

नोट: कभी भी इसका उपयोग "".toString().toString().toString();रास्ते की तरह न करें ।

Answer 15

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

Answer 16

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

Answer 17

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

class StorageUtil {
  public static ArrayList<Employee> employees;
}

फिर डेटा को टुकड़ा से गतिविधि तक पहुंचाने के लिए, हम ऐसा करते हैं onActivityCreated विधि:

//a field created in the sending fragment
ArrayList<Employee> employees;

@Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
         employees=new ArrayList();

       //java 7 and above syntax for arraylist else use employees=new ArrayList<Employee>() for java 6 and below

     //Adding first employee
        Employee employee=new Employee("1","Andrew","Sam","1984-04-10","Male","Ghanaian");
        employees.add(employee);

      //Adding second employee
       Employee employee=new Employee("1","Akuah","Morrison","1984-02-04","Female","Ghanaian");
         employees.add(employee);

        StorageUtil.employees=employees;
    }

अब आप StorageUtil.employees का मान हर जगह से प्राप्त कर सकते हैं। सौभाग्य!

Answer 18

मेरा समाधान टुकड़े के अंदर एक स्थिर विधि लिखना है:

public TheFragment setData(TheData data) {
    TheFragment tf = new TheFragment();
    tf.data = data;
    return tf;
}

इस तरह मुझे यकीन है कि किसी भी अन्य संभावित ऑपरेशन से पहले मुझे आवश्यक सभी डेटा फ्रैगमेंट के अंदर हैं जो इसके साथ काम करने की आवश्यकता हो सकती है। इसके अलावा यह मेरी राय में क्लीनर दिखता है।

Comments

ठीक है, अगर TheData थ्रेड सुरक्षित नहीं है, तो इसे स्थिर बनाने से आपको थ्रेड मुद्दों से सुरक्षा नहीं मिलेगी। उससे सावधान। स्वभाव से स्थिर धागा सुरक्षित नहीं है।

— मार्टिन मार्कोसिनी

Answer 19

मैं नवीनतम नेविगेशन आर्किटेक्चर घटक का उपयोग करते समय एक समान समस्या में भाग गया। मेरी कॉलिंग गतिविधि से लेकर फ्रेग्मेंट तक एक बंडल पास करने के साथ उपरोक्त सभी कोड की कोशिश की।

एंड्रॉइड में नवीनतम विकास के रुझान के बाद सबसे अच्छा समाधान, व्यू मॉडल (एंड्रॉइड जेटपैक का हिस्सा) का उपयोग करके है।

मूल गतिविधि में एक ViewModel वर्ग बनाएँ और प्रारंभ करें, कृपया ध्यान दें कि इस ViewModel को गतिविधि और टुकड़े के बीच साझा किया जाना है।

अब, अंदर के OnViewCreated () खंड के, ViewModel फ़ील्ड को सुनने के लिए समान ViewModel और सेटअप ऑब्जर्वर को प्रारंभ करें।

यदि आवश्यक हो तो यहाँ एक सहायक, इन-डेप्थ ट्यूटोरियल है।

https://medium.com/mindorks/how-to-communicate-between-fragments-and-activity-using-viewmodel-ca733233a51c

Answer 20

अपनी गतिविधि में स्थिर चर घोषित करें

public static HashMap<String,ContactsModal> contactItems=new HashMap<String, ContactsModal>();

फिर अपने टुकड़े में पालन की तरह करते हैं

ActivityName.contactItems.put(Number,contactsModal);

Comments

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

— एम शाबान अली