DialogFragment से परिणाम प्राप्त करें

Question

मैं कई चीजों के लिए DialogFragments का उपयोग कर रहा हूं : सूची से आइटम चुनना, पाठ दर्ज करना।

मूल्य वापस करने का सबसे अच्छा तरीका क्या है (यानी एक सूची से एक स्ट्रिंग या एक आइटम) वापस कॉलिंग गतिविधि / टुकड़ा करने के लिए?

वर्तमान में मैं कॉलिंग गतिविधि को लागू कर रहा हूं DismissListenerऔर डायलॉगफ्रैगमेंट को गतिविधि का संदर्भ दे रहा हूं। तब संवाद OnDimissगतिविधि में विधि को बुलाता है और गतिविधि DialogFragment ऑब्जेक्ट से परिणाम पकड़ती है। बहुत गन्दा है और यह कॉन्फ़िगरेशन परिवर्तन (अभिविन्यास परिवर्तन) पर काम नहीं करता है क्योंकि DialogFragment गतिविधि का संदर्भ खो देता है।

किसी भी मदद के लिए धन्यवाद।

Comments

DialogFragments अभी भी केवल टुकड़े हैं। आपका दृष्टिकोण वास्तव में मुख्य गतिविधि पर वापस बात करने के लिए टुकड़ों के उपयोग के लिए अनुशंसित तरीका है। developer.android.com/guide/topics/fundamentals/…

— कोडिंगसियर

उसके लिए धन्यवाद। मैं बहुत करीब था (जैसा कि आपने कहा)। उस दस्तावेज़ से जुड़े बिट ने मुझे onAttach () का उपयोग करने और एक श्रोता को गतिविधि कास्ट करने में मदद की।

— जेम्स क्रॉस

@codinguser, @Styx - "डायलॉगफ्रैगमेंट को गतिविधि का एक संदर्भ दे रहा है" - यह विवरण थोड़ा जोखिम भरा है, क्योंकि दोनों को Activityऔर DialogFragmentफिर से बनाया जा सकता है। Activityउत्तीर्ण का उपयोग onAttach(Activity activity)उचित और अनुशंसित तरीका है।

— sstn

Answer 1

myDialogFragment.setTargetFragment(this, MY_REQUEST_CODE)उस जगह से उपयोग करें जहां आप संवाद दिखाते हैं, और फिर जब आपका संवाद समाप्त हो जाता है, तो उसमें से आप कॉल कर सकते हैं getTargetFragment().onActivityResult(getTargetRequestCode(), ...)और onActivityResult()युक्त अंश में लागू कर सकते हैं।

यह एक दुरुपयोग की तरह लगता है onActivityResult(), खासकर जब यह गतिविधियों को बिल्कुल शामिल नहीं करता है। लेकिन मैंने इसे आधिकारिक Google लोगों द्वारा अनुशंसित देखा है, और शायद एपीआई डेमो में भी। मुझे लगता है कि यह वही है जो g/setTargetFragment()इसके लिए जोड़ा गया था।

Comments

setTargetFragment में उल्लेख किया गया है कि अनुरोध कोड onActivityResult में उपयोग के लिए है, इसलिए मुझे लगता है कि इस दृष्टिकोण का उपयोग करना ठीक है।

— गियोर्गी

क्या होगा यदि लक्ष्य एक गतिविधि है?

— फर्नांडो गैलेगो

यदि लक्ष्य गतिविधि है तो मैं "void onActivityResult2 (int requestCode, int resultCode, Intent data)" जैसी विधि के साथ इंटरफ़ेस घोषित करूंगा और इसे एक गतिविधि द्वारा कार्यान्वित करूंगा। DialogFragment में बस getActivity और इस इंटरफ़ेस के लिए जाँच करें और इसे उचित रूप से कॉल करें।

— रुसलान यानिशिन

यह अच्छा समाधान नहीं है। संवाद खंड स्थिति को बचाने और पुनर्स्थापित करने के बाद यह काम नहीं करेगा। LocalBroadcastManager इस मामले में सबसे अच्छा समाधान है।

— निक

@ नाइक यह सच नहीं है। यह सबसे अच्छा उपाय है। राज्य को बचाने और बहाल करने में कोई समस्या नहीं है। यदि आपको कभी कोई समस्या हुई थी तो आपने गलत टुकड़ा प्रबंधक का उपयोग किया था। संवाद को दिखाने के लिए getChildFragmentManager () का उपयोग करने के लिए लक्ष्य खंड / कॉलर hast।

— 13 जनवरी को अविश्वसनीय जन

Answer 2

आप देख सकते हैं यहाँ वहाँ ऐसा करने के लिए एक बहुत ही सरल तरीका है।

अपने DialogFragmentऐड इंटरफ़ेस में श्रोता जैसे:

public interface EditNameDialogListener {
    void onFinishEditDialog(String inputText);
}

फिर, उस श्रोता के लिए एक संदर्भ जोड़ें:

private EditNameDialogListener listener;

इसका उपयोग श्रोता विधि (ओं) को "सक्रिय" करने के लिए किया जाएगा, और यह भी जांचने के लिए कि क्या पैरेंट एक्टिविटी / फ्रैगमेंट इस इंटरफ़ेस को लागू करता है (नीचे देखें)।

में Activity/ FragmentActivity/ Fragmentकि "बुलाया" DialogFragmentबस इस इंटरफ़ेस को लागू करें।

अपने DialogFragmentसभी में आपको उस बिंदु पर जोड़ना होगा जहां आप इसे खारिज करना चाहते DialogFragmentहैं और परिणाम वापस करना है:

listener.onFinishEditDialog(mEditText.getText().toString());
this.dismiss();

कहाँ mEditText.getText().toString()क्या वापस फोन करने के लिए पारित हो जाएगा है Activity।

ध्यान दें कि यदि आप कुछ और वापस करना चाहते हैं तो बस उन तर्कों को बदल दें जो श्रोता लेता है।

अंत में, आपको जांचना चाहिए कि क्या इंटरफ़ेस वास्तव में मूल गतिविधि / खंड द्वारा लागू किया गया था:

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    // Verify that the host activity implements the callback interface
    try {
        // Instantiate the EditNameDialogListener so we can send events to the host
        listener = (EditNameDialogListener) context;
    } catch (ClassCastException e) {
        // The activity doesn't implement the interface, throw exception
        throw new ClassCastException(context.toString()
                + " must implement EditNameDialogListener");
    }
}

यह तकनीक बहुत लचीली है और अगर आपके डॉन अभी भी संवाद को खारिज नहीं करना चाहते हैं, तो परिणाम के साथ कॉल करने की अनुमति दें।

Comments

यह Activity's और FragmentActivity' s के साथ बहुत अच्छा काम करता है, लेकिन अगर कॉलर a है Fragment?

— ब्रिस गैबिन

मुझे यकीन नहीं है कि मैं आपको पूरी तरह से समझता हूं। लेकिन यह उसी तरह काम करेगा यदि कॉलर ए है Fragment।

— असफ गमलील

यदि कॉल करने वाला था Fragmentतो आप कुछ चीजें कर सकते हैं: 1. एक संदर्भ के रूप में टुकड़ा पास करें (हो सकता है कि यह एक अच्छा विचार न हो क्योंकि आप मेमोरी लीक का कारण हो सकते हैं)। 2. FragmentManagerकॉल और कॉल का उपयोग करें findFragmentByIdया findFragmentByTagइसे आपकी गतिविधि में मौजूद टुकड़े मिलेंगे। मुझे उम्मीद है कि इससे मदद मिली। आपका दिन अच्छा रहे!

— असफ गमलील

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

— Necotet

@LOG_TAG @ टिम्मम के उत्तर को देखें। setTargetFragment()और getTargetFragment()जादू हैं।

— ब्रिस गाबिन

Answer 3

DialogFragment से परिणाम प्राप्त करने का एक बहुत सरल तरीका है।

सबसे पहले, अपनी गतिविधि, टुकड़ा, या FragmentActivity में आपको निम्न जानकारी जोड़ने की आवश्यकता है:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    // Stuff to do, dependent on requestCode and resultCode
    if(requestCode == 1) { // 1 is an arbitrary number, can be any int
         // This is the return result of your DialogFragment
         if(resultCode == 1) { // 1 is an arbitrary number, can be any int
              // Now do what you need to do after the dialog dismisses.
         }
     }
}

requestCodeमूल रूप से DialogFragment आप बुलाया के लिए अपने पूर्णांक लेबल है, मैं दिखाता हूँ कैसे एक सेकंड में यह काम करता है। परिणाम कोड वह कोड होता है जिसे आप अपने वर्तमान प्रतीक्षा गतिविधि, फ़्रैगमेंट या फ़्रैगमेंटएक्टिविटी बताकर डायलॉग फ़्रेग्मेंट से वापस भेजते हैं।

में जाने के लिए कोड का अगला टुकड़ा डायलॉगफ्रैगमेंट के लिए कॉल है। एक उदाहरण यहाँ है:

DialogFragment dialogFrag = new MyDialogFragment();
// This is the requestCode that you are sending.
dialogFrag.setTargetFragment(this, 1);     
// This is the tag, "dialog" being sent.
dialogFrag.show(getFragmentManager(), "dialog");

इन तीन पंक्तियों के साथ आप अपने DialogFragment की घोषणा कर रहे हैं, एक RequestCode (जिसे onActivityResult (...) कहेंगे, एक बार डायलॉग खारिज होने के बाद, और आप डायलॉग दिखा रहे हैं, सेट करते हुए। यह सरल है।

अब, अपने DialogFragment में आपको सिर्फ एक लाइन को सीधे जोड़ने की जरूरत है dismiss()ताकि आप onActivityResult () पर एक परिणाम भेज सकें।

getTargetFragment().onActivityResult(getTargetRequestCode(), resultCode, getActivity().getIntent());
dismiss();

बस। ध्यान दें, resultCode परिभाषित किया गया है int resultCodeजो मैंने resultCode = 1;इस मामले में निर्धारित किया है।

बस, अब आप अपने DialogFragment के परिणाम को अपनी कॉलिंग गतिविधि, फ़्रैगमेंट या Fragment.ctivity पर वापस भेज सकते हैं।

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

EDIT 06.24.2016 ऊपर दिए गए भ्रामक कोड के लिए मैं क्षमा चाहता हूँ। लेकिन आप निश्चित रूप से लाइन के रूप में देखकर गतिविधि को परिणाम वापस नहीं पा सकते हैं:

dialogFrag.setTargetFragment(this, 1);

एक लक्ष्य निर्धारित करता है Fragmentऔर नहीं Activity। तो ऐसा करने के लिए आपको कार्यान्वयन a का उपयोग करने की आवश्यकता है InterfaceCommunicator।

अपने DialogFragmentसेट में एक वैश्विक चर

public InterfaceCommunicator interfaceCommunicator;

इसे संभालने के लिए एक सार्वजनिक समारोह बनाएँ

public interface InterfaceCommunicator {
    void sendRequestCode(int code);
}

फिर जब आप कोड को वापस भेजने के लिए तैयार हो जाते हैं Activityजब DialogFragmentचल रहा होता है, तो आप बस dismiss();अपने से पहले लाइन जोड़ते हैं DialogFragment:

interfaceCommunicator.sendRequestCode(1); // the parameter is any int code you choose.

आपकी गतिविधि में अब आपको दो काम करने होंगे, पहला यह है कि कोड की एक पंक्ति को हटा दें जो अब लागू नहीं है:

dialogFrag.setTargetFragment(this, 1);  

फिर इंटरफ़ेस लागू करें और आप सभी काम कर रहे हैं। आप निम्न implementsवर्ग को अपनी कक्षा के सबसे ऊपर स्थित खंड में जोड़कर ऐसा कर सकते हैं :

public class MyClass Activity implements MyDialogFragment.InterfaceCommunicator

और फिर @Overrideगतिविधि में कार्य करता है,

@Override
public void sendRequestCode(int code) {
    // your code here
}

आप इस इंटरफ़ेस विधि का उपयोग उसी तरह करेंगे जैसे आप onActivityResult()विधि करेंगे । सिवाय इंटरफ़ेस विधि के लिए है DialogFragmentsऔर अन्य के लिए है Fragments।

Comments

यदि लक्ष्य गतिविधि है तो यह दृष्टिकोण काम नहीं करेगा क्योंकि आप संरक्षित पहुंच स्तर के कारण इसके onActivityResult (अपने DialogFragment से) को कॉल नहीं कर सकते हैं।

— रुस्लान यानिशिन

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

— ब्रैंडन

नमस्ते, आप कहते हैं कि आप dialogFrag.setTargetFragment(this, 1)किसी गतिविधि से कॉल कर सकते हैं , लेकिन इस पद्धति को पहले तर्क के रूप में एक फ़्रैगमेंट प्राप्त होता है, इसलिए इसे कास्ट नहीं किया जा सकता है। क्या मैं सही हू ?

— 20

मैं गतिविधि सामग्री को समझाने के लिए आप सभी के लिए कुछ प्रतिक्रियाओं को पोस्ट करूँगा।

— ब्रैंडन

@Swift @lcompare आपको शायद अपने DialogFragment में onAttach (संदर्भ संदर्भ) को ओवरराइड करने की आवश्यकता है। जैसे:@Override public void onAttach(Context context) { super.onAttach(context); yourInterface = (YourInterface) context; }

— लिडकंक्स

Answer 4

खैर इसका जवाब देने में बहुत देर हो सकती है लेकिन यहाँ से मैंने परिणाम वापस पाने के लिए क्या किया DialogFragment। @ ब्रैंडन के उत्तर के समान। यहां मैं DialogFragmentएक खंड से कॉल कर रहा हूं , बस इस कोड को रखें जहां आप अपना डायलॉग बोल रहे हैं।

FragmentManager fragmentManager = getFragmentManager();
            categoryDialog.setTargetFragment(this,1);
            categoryDialog.show(fragmentManager, "dialog");

categoryDialogमेरा वह स्थान कहां है DialogFragmentजिसे मैं कॉल करना चाहता हूं और इसके बाद dialogfragmentइस कोड के कार्यान्वयन में जहां आप अपना डेटा जानबूझकर सेट कर रहे हैं। का मान resultCode1 है आप इसे सेट कर सकते हैं या सिस्टम डिफाइंड का उपयोग कर सकते हैं।

            Intent intent = new Intent();
            intent.putExtra("listdata", stringData);
            getTargetFragment().onActivityResult(getTargetRequestCode(), resultCode, intent);
            getDialog().dismiss();

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

 @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);        
        //do what ever you want here, and get the result from intent like below
        String myData = data.getStringExtra("listdata");
Toast.makeText(getActivity(),data.getStringExtra("listdata"),Toast.LENGTH_SHORT).show();
    }

Answer 5

भिन्न दृष्टिकोण, अपनी गतिविधि तक संचार करने के लिए एक टुकड़ा की अनुमति देने के लिए :

1) टुकड़े में एक सार्वजनिक इंटरफ़ेस को परिभाषित करें और इसके लिए एक चर बनाएं

public OnFragmentInteractionListener mCallback;

public interface OnFragmentInteractionListener {
    void onFragmentInteraction(int id);
}

2) टुकड़ा में mCallback चर के लिए गतिविधि कास्ट करें

try {
    mCallback = (OnFragmentInteractionListener) getActivity();
} catch (Exception e) {
    Log.d(TAG, e.getMessage());
}

3) अपनी गतिविधि में श्रोता को लागू करें

public class MainActivity extends AppCompatActivity implements DFragment.OnFragmentInteractionListener  {
     //your code here
}

4) गतिविधि में OnFragmentInteraction को ओवरराइड करें

@Override
public void onFragmentInteraction(int id) {
    Log.d(TAG, "received from fragment: " + id);
}

इस पर अधिक जानकारी: https://developer.android.com/training/basics/fragments/communicating.html

Comments

इसे इतनी अच्छी तरह से सारांशित करने के लिए धन्यवाद। दूसरों के लिए सिर्फ एक नोट, एंड्रॉइड देवता ट्यूटोरियल public void onAttachके टुकड़े को ओवरराइड करने और वहां कास्टिंग गतिविधि करने का सुझाव देता है

— Big_Chair

Answer 6

एक आसान तरीका मुझे निम्नलिखित मिला: इसे लागू करें अपने संवाद है,

  CallingActivity callingActivity = (CallingActivity) getActivity();
  callingActivity.onUserSelectValue("insert selected value here");
  dismiss();

और फिर डायलॉग फ्रैगमेंट नामक गतिविधि में उपयुक्त फ़ंक्शन बनाएं जैसे:

 public void onUserSelectValue(String selectedValue) {

        // TODO add your implementation.
      Toast.makeText(getBaseContext(), ""+ selectedValue, Toast.LENGTH_LONG).show();
    }

टोस्ट यह दिखाने के लिए है कि यह काम करता है। मेरे लिए काम किया।

Comments

मुझे यकीन नहीं है कि यह करने का एक सही तरीका है, लेकिन यह निश्चित रूप से काम करता है :)

— soshial

Interfaceकंक्रीट कक्षाओं के साथ हार्ड-कपलिंग के बजाय बेहतर उपयोग ।

— वकासलम

Answer 7

मैं बहुत देखने के लिए कि कोई सुझाव दिया है के लिए स्थानीय प्रसारण का उपयोग कर हैरान कर रहा हूँ DialogFragmentकरने के लिए Activityसंचार! मुझे यह अन्य सुझावों की तुलना में बहुत सरल और साफ लग रहा है। अनिवार्य रूप से, आप अपने Activityप्रसारणों के लिए सुनने के लिए पंजीकरण करते हैं और आप अपने DialogFragmentउदाहरणों से स्थानीय प्रसारण भेजते हैं । सरल। यह सब कैसे सेट किया जाए, इसके बारे में चरण-दर-चरण मार्गदर्शिका के लिए, यहां देखें ।

Comments

मुझे वह समाधान पसंद है, क्या यह एंड्रॉइड में एक अच्छा या सबसे अच्छा अभ्यास माना जाता है?

— बेंजामिन शरबाउ

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

— ब्रैंडन

@ AdilHussain तुम सही हो। मैंने यह धारणा बनाई कि लोग अपनी गतिविधियों के भीतर Fragments का उपयोग कर रहे थे। यदि आप एक फ्रैगमेंट और एक डायलॉगफ्रैगमेंट के साथ संचार कर रहे हैं, तो setTargetFragment विकल्प बहुत अच्छा है। लेकिन आपको ब्रॉडकास्ट पद्धति का उपयोग करने की आवश्यकता है जब यह डायलॉगफ्रैगमेंट नामक एक गतिविधि है।

— ब्रैंडन

फू के प्यार के लिए, ब्रॉडकास्ट का उपयोग न करें !! यह आपके एप्लिकेशन को सुरक्षा समस्याओं के एक स्लू के लिए खोलता है। इसके अलावा, मुझे लगता है कि सबसे खराब Android एप्लिकेशन को मुझे दुरुपयोग प्रसारण पर काम करना है। क्या आप कोड को पूरी तरह अनुपयोगी बनाने के लिए बेहतर तरीके से सोच सकते हैं? अब मुझे कोड की CLEAR लाइन के बजाय ब्रॉडकास्ट रिसीवर्स को रूट करना होगा? स्पष्ट होने के लिए ब्रॉडकास्ट के लिए उपयोग हैं, लेकिन इस संदर्भ में नहीं! इस संदर्भ में कभी नहीं! यह सिर्फ मैला है। स्थानीय या नहीं। कॉलबैक आप सभी की जरूरत है।

— StarWind0

साथ ही अमरूद EventBus एक और विकल्प GreenRobot EventBus है । मैंने अमरूद इवेंटबस का उपयोग नहीं किया है, लेकिन ग्रीनरॉट इवेंटबस का उपयोग किया है और इसके साथ एक अच्छा अनुभव रहा है। अच्छा और प्रयोग करने में सरल। GreenRobot EventBus का उपयोग करने के लिए एंड्रॉइड एप्लिकेशन को कैसे आर्किटेक्चर करना है, इसके एक छोटे से उदाहरण के लिए, यहां देखें ।

— आदिल हुसैन

Answer 8

या ViewModel को यहाँ साझा करें:

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData<Item> getSelected() {
        return selected;
    }
}


public class MasterFragment extends Fragment {
    private SharedViewModel model;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update the UI.
        });
    }
}

https://developer.android.com/topic/libraries/architecture/viewmodel#sharing_data_between_fragments

Answer 9

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

 ((Interface)getTargetFragment()).onSomething(selectedListPosition);

Answer 10

कोटलिन में

    // My DialogFragment
class FiltroDialogFragment : DialogFragment(), View.OnClickListener {
    
    var listener: InterfaceCommunicator? = null

    override fun onAttach(context: Context?) {
        super.onAttach(context)
        listener = context as InterfaceCommunicator
    }

    interface InterfaceCommunicator {
        fun sendRequest(value: String)
    }   

    override fun onClick(v: View) {
        when (v.id) {
            R.id.buttonOk -> {    
        //You can change value             
                listener?.sendRequest('send data')
                dismiss()
            }
            
        }
    }
}

// मेरी गतिविधि

class MyActivity: AppCompatActivity(),FiltroDialogFragment.InterfaceCommunicator {

    override fun sendRequest(value: String) {
    // :)
    Toast.makeText(this, value, Toast.LENGTH_LONG).show()
    }
}
 

मुझे आशा है कि यह कार्य करता है, अगर आप इसे संपादित करने में सुधार कर सकते हैं। मेरी अंग्रेजी बहुत अच्छी नहीं है

Comments

मेरे मामले में संवाद एक खंड नहीं गतिविधि से बनाया गया है ताकि यह समाधान काम न करे। लेकिन मुझे आपके द्वारा लगाई गई स्माइली पसंद है :)

— सेशिएनजो

Answer 11

यदि आप तर्क भेजना चाहते हैं और दूसरे टुकड़े से परिणाम प्राप्त करना चाहते हैं, तो आप इस कार्य को पूरा करने के लिए Fragment.setArguments का उपयोग कर सकते हैं

static class FirstFragment extends Fragment {
    final Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case 101: // receive the result from SecondFragment
                Object result = msg.obj;
                // do something according to the result
                break;
            }
        };
    };

    void onStartSecondFragments() {
        Message msg = Message.obtain(mUIHandler, 101, 102, 103, new Object()); // replace Object with a Parcelable if you want to across Save/Restore
                                                                               // instance
        putParcelable(new SecondFragment(), msg).show(getFragmentManager().beginTransaction(), null);
    }
}

static class SecondFragment extends DialogFragment {
    Message mMsg; // arguments from the caller/FirstFragment

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onViewCreated(view, savedInstanceState);
        mMsg = getParcelable(this);
    }

    void onClickOK() {
        mMsg.obj = new Object(); // send the result to the caller/FirstFragment
        mMsg.sendToTarget();
    }
}

static <T extends Fragment> T putParcelable(T f, Parcelable arg) {
    if (f.getArguments() == null) {
        f.setArguments(new Bundle());
    }
    f.getArguments().putParcelable("extra_args", arg);
    return f;
}
static <T extends Parcelable> T getParcelable(Fragment f) {
    return f.getArguments().getParcelable("extra_args");
}

Answer 12

बस इसे विकल्पों में से एक के रूप में है (क्योंकि किसी ने अभी तक इसका उल्लेख नहीं किया है) - आप ओटो जैसी एक घटना बस का उपयोग कर सकते हैं। तो आप संवाद में:

bus.post(new AnswerAvailableEvent(42));

और अपने कॉलर (गतिविधि या टुकड़ा) की सदस्यता लें:

@Subscribe public void answerAvailable(AnswerAvailableEvent event) {
   // TODO: React to the event somehow!
}