onActivityResult को Fragment में नहीं कहा जा रहा है

Question

onActivityResultजब कैमरा गतिविधि वापस आती है, तो इस खंड को होस्ट करने वाली गतिविधि को बुलाया जाता है।

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

ImageView myImage = (ImageView)inflatedView.findViewById(R.id.image);
myImage.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
        startActivityForResult(cameraIntent, 1888);
    }
});

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if( requestCode == 1888 ) {
        Bitmap photo = (Bitmap) data.getExtras().get("data");
        ((ImageView)inflatedView.findViewById(R.id.image)).setImageBitmap(photo);
    }
}

Comments

इस पोस्ट की जाँच करें, समस्या का वर्णन और आम समाधान है: stackoverflow.com/questions/6147884/…

— Oleksii K.

इसे पढ़ने वाला कोई भी व्यक्ति सुनिश्चित करें कि आप पास हैं requestCode >= 0!

— मुहम्मद बाबर

यह भी सुनिश्चित करें कि आपकी गतिविधि LauchMode को सिंगल इनस्टेंस या सिंगलटेस्क नहीं होना चाहिए। अन्यथा onActivityResult नहीं कहा जाएगा

— Jawad Zeb

इस लिंक को देखें इससे आपको मदद मिल सकती है: androidtutorialonline.com/onactivityresult-in-fragment

— Android Tutorial

हमें गतिविधि में फ़्रैगमेंट में onActivityResult को पुनर्निर्देशित करने की आवश्यकता है। इस लिंक को देखें: codexpedia.com/android/…

— Reejesh PK

Answer 1

होस्टिंग गतिविधि ओवरराइड करती है onActivityResult(), लेकिन इसने super.onActivityResult()अनहेल्ड परिणाम कोड के लिए कॉल नहीं किया । जाहिर है, भले ही टुकड़ा एक startActivityForResult()कॉल कर रहा हो, फिर भी गतिविधि को परिणाम को संभालने में पहली गोली मिलती है। यह समझ में आता है जब आप अंशों के प्रतिरूप पर विचार करते हैं। एक बार जब मैंने super.onActivityResult()सभी अनचाहे परिणामों के लिए लागू किया, तो परिणाम को संभालने के लिए टुकड़े को एक शॉट मिला।

और @ जवाब से भी:

अपने टुकड़े में परिणाम प्राप्त करने के लिए सुनिश्चित करें कि आप अपने टुकड़े startActivityForResult(intent,111);के getActivity().startActivityForResult(intent,111);अंदर के बजाय कॉल करते हैं।

Comments

आपकी गतिविधि के onActivityResult में, super.onActivityResult ()

— Spidy

@StErMi सुनिश्चित करें कि आप अपने अंश से startActivityForResult () और not getActivity ()। StartActivityForResult () कॉल करें। नीचे दिए गए उत्तर को देखें।

— 19

वहाँ एक संबंधित बग, जहां समर्थन पुस्तकालय किया जा रहा है प्रतीत होता है code.google.com/p/android/issues/detail?id=15394

— ओली सी

यह भी ध्यान दें कि यदि आप नेस्टेड टुकड़े का उपयोग कर रहे हैं, तो बच्चे के टुकड़े को कॉल करना चाहिए getParentFragment().startActivityForResultताकि माता-पिता के टुकड़े में इसकी onActivityResult विधि हो।

— एरिक ब्रायनवॉल्ड 15

@ EricBrynsvold सही था, startActivityForResult नेस्टेड टुकड़ों में काम नहीं करता है। इसके लिए, आप बेहतर कॉल getParentFragment ()। StartActivityForResult (), और उस मूल खंड में, उसके बाद, आप onActivityResult () को लागू कर सकते हैं और उस विधि में बच्चे के टुकड़े करने का परिणाम देते हैं, अर्थात: childFragment.getParentFragment ()। onActivityResult (requestCode, resultCode, डेटा)

— एड्रियन

Answer 2

मुझे लगता है कि आपने फोन किया getActivity().startActivityForResult(intent,111);। आपको फोन करना चाहिए startActivityForResult(intent,111);।

Comments

मैं भी RingtonePreferenceस्थित में एक ही समस्या थी PreferenceFragment। दुर्भाग्य से, RingtonePreferenceकॉल getActivity().startActivityForResult(), और मुझे super.onActivityResultगतिविधि में कॉल करने के बावजूद परिणाम नहीं मिला onActivityResult। मुझे RingtonePreferenceकक्षा से व्युत्पन्न बनाने के लिए मजबूर किया गया था , जो खुद को PreferenceFragmentऔर कॉल के लिए बाध्य करता है fragment.startActivityForResult()।

— स्टेन

@ बाइंग मैं अपने स्थिर तरीके से startActivitForResult को कॉल करने में सक्षम नहीं हूं। उसके लिए कोई उपाय? मुझे activity.startActivityForResult का उपयोग करना होगा। कृपया इसमें मेरी मदद करें

— श्रेयश महाजन

Answer 3

विकल्प 1:

यदि आप startActivityForResult()खंड से कॉल कर रहे हैं , तो आपको कॉल करना चाहिए startActivityForResult(), न कि getActivity().startActivityForResult(), क्योंकि इसका परिणाम onActivityResult () होगा।

यदि आप सुनिश्चित नहीं हैं कि आप कहां पर कॉल कर रहे हैं startActivityForResult()और आप कैसे कॉलिंग विधि करेंगे।

विकल्प 2:

चूंकि गतिविधि का परिणाम प्राप्त होता है onActivityResult(), इसलिए आपको गतिविधि के ओवरराइड करने और संबंधित खंडों या सभी के लिए संबंधित खंड में प्रचार करने के लिए onActivityResult()कॉल super.onActivityResult()करना होगा।

यदि उपरोक्त दो विकल्प काम नहीं करते हैं, तो विकल्प 3 देखें क्योंकि यह निश्चित रूप से काम करेगा।

विकल्प 3:

टुकड़े से onActivityResult फ़ंक्शन के लिए एक स्पष्ट कॉल इस प्रकार है।

पैरेंट एक्टिविटी क्लास में, onActivityResult () मेथड को ओवरराइड करें और यहां तक ​​कि फ्रैगमेंट क्लास में भी ओवरराइड करें और निम्न कोड के रूप में कॉल करें।

मूल वर्ग में:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    Fragment fragment = getSupportFragmentManager().findFragmentById(R.id.dualPane);
    fragment.onActivityResult(requestCode, resultCode, data);
}

बच्चे की कक्षा में:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // In fragment class callback
}

Comments

इसने मेरे लिए काम किया। यह एक बुरा काम है, लेकिन मेरे पास इस मुहावरेदार बग को हल करने के लिए बेहतर विचार नहीं है ...

— बोगदान ज़ुरैक

@Vivky, आपके जवाब ने मेरे लिए काम किया। लेकिन एक और समस्या है जिसका मैं सामना कर रहा हूं, इसके बजाय setResult(); finish();जब मैं दूसरी गतिविधि से वापस प्रेस करता हूं तो onActivityResultप्रदान के साथ भी बुलाया जाता है RESULT_CODE।

— snehal_penurkar

शानदार जवाब। मैंने इसे पूरा करने के लिए तीसरा समाधान लागू किया।

— Sash_KP

मुझे लगता है कि समाधान 3 मेरे लिए काम करेगा, लेकिन onActivityResult()गतिविधि का एक अजीब लौटता है requestCodeजो मेरे टुकड़े में पारित हो जाता है और फिर नजरअंदाज कर दिया जाता है = /

— ई-कामी

@notGeek आप सही हैं। खंड या गतिविधि से बुलाए जाने पर भी परिणाम हमेशा गतिविधि में शामिल होता है।

— विनायक

Answer 4

यदि आप अपनी गतिविधि में अंशों को नहीं जानते हैं, तो उन सभी को संलग्न करें और गतिविधि परिणाम तर्क भेजें:

// In your activity
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    for (Fragment fragment : getSupportFragmentManager().getFragments()) {
        fragment.onActivityResult(requestCode, resultCode, data);
    }
}

Comments

लानत है, मुझे लगता है कि मैं सिर्फ सबसे सरल समाधान पाया, लेकिन getFragments () के रूप में ऐसी कोई विधि नहीं है।

— विंडराइडर

@WindRider है। यदि आप Android समर्थन पुस्तकालय (AppCompat) का उपयोग करते हैं।

— देसर

इसके अलावा, मैंने यह भी कठिन तरीका सीखा कि आपको यह देखना होगा कि सरणी में टुकड़ा अपने आप में संदर्भ नहीं है! `अगर (टुकड़ा! = यह) {टुकड़ा। aonctivityResult (requestCode, resultCode, डेटा); `

— 17

यह काम नहीं करता है अगर टुकड़े को नेस्टेड किया जाता है, क्योंकि सूची में केवल शीर्ष टुकड़ा होगा। मेरा मानना ​​है कि सूची में सभी अंशों पर super.onActivityResult () पहले से ही onActivityResult () कॉल कर रहा है, इसलिए यह विचार बेमानी है।

— बेक्काप

stackoverflow.com/questions/27343945/…

— maruti060385

Answer 5

मैं एक ही समस्या के साथ कर रहा हूँ ChildFragmentManager। प्रबंधक परिणाम को नेस्टेड टुकड़े को पारित नहीं करेगा, आपको यह करना होगा कि मैन्युअल रूप से आपके आधार टुकड़े में।

public void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);
    Fragment fragment = (Fragment) getChildFragmentManager().findFragmentByTag(childTag);
    if (fragment != null) {
        fragment.onActivityResult(requestCode, resultCode, intent);
    }
}

Comments

यदि आपके पास एक निजी सदस्य के रूप में आपका बच्चा फ्रैगमेंट है, तो कोड Fragment fragment = myChildFragment;की उपरोक्त findFragmentByTagपंक्ति को बदलने के लिए उपयोग करें । बाकी को अपरिवर्तित रखा जा सकता है।

— lcn

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

— मिंसमैन

Answer 6

मूल पोस्ट।

FragmentActivityrequestCodeएक संशोधित द्वारा प्रतिस्थापित करता है। उसके बाद, जब onActivityResult()आह्वान किया जाएगा, FragmentActivityउच्च 16 बिट्स को पार्स करता है और मूल टुकड़े के सूचकांक को पुनर्स्थापित करता है। इस योजना को देखें:

यदि आपके पास रूट स्तर पर कुछ टुकड़े हैं, तो कोई समस्या नहीं है। लेकिन अगर आपके पास नेस्टेड टुकड़े हैं , उदाहरण के लिए Fragmentअंदर कुछ टैब के साथ ViewPager, आपने गारंटी दी है कि समस्या का सामना करना पड़ेगा (या पहले से ही इसका सामना करना पड़ा)।

क्योंकि केवल एक इंडेक्स अंदर जमा होता है requestCode। यह Fragmentइसके अंदर का सूचकांक है FragmentManager। जब हम नेस्टेड अंशों का उपयोग कर रहे हैं, तो बच्चे के FragmentManagerएस हैं, जिनकी फ्रैगमेंट की अपनी सूची है। इसलिए, रूट से शुरू होकर सूचकांकों की पूरी श्रृंखला को बचाना आवश्यक है FragmentManager।

हम इस मुद्दे को कैसे हल करेंगे? इस पोस्ट में आम समाधान समाधान है ।

गिटहब: https://github.com/shamanland/nested-fragment-issue

Comments

मेरे पास एक ही मुद्दा है क्योंकि मैंने माता-पिता के टुकड़े में एक ViewPager का उपयोग किया था जो अन्य टुकड़ों को टैब के रूप में रखता है। नेस्टेड-टुकड़ा-मुद्दे का उपयोग करने की कोशिश की लेकिन संकलन इरोज़ के साथ समाप्त हो गया। क्या आप मुझे इसका समाधान सुझा सकते हैं? भी यहाँ एक मुद्दों को उठाया github.com/shamanland/nested-fragment-issue/issues/2

— CGR

मैंने गितुब पर जवाब दिया, तो चलिए इस बातचीत को यहाँ से आगे बढ़ाते

— Oleksii K.

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

— cgr

Answer 7

यह सबसे लोकप्रिय मुद्दे में से एक है। हम इस मुद्दे के बारे में बहुत सारे सूत्र पा सकते हैं। लेकिन उनमें से कोई भी मेरे लिए उपयोगी नहीं है।

इसलिए मैंने इस समाधान का उपयोग करके इस समस्या को हल किया है।

आइए पहले समझते हैं कि ऐसा क्यों हो रहा है।

हम startActivityForResultसीधे फ्रैगमेंट से कॉल कर सकते हैं लेकिन वास्तव में मैकेनिक पीछे सभी गतिविधि द्वारा नियंत्रित होते हैं।

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

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

यह समस्या है:

गतिविधि परिणाम को केवल उस फ़्रैगमेंट में भेज सकती है जिसे सीधे गतिविधि में संलग्न किया गया है लेकिन नेस्टेड को नहीं। यही कारण है कि घोंसले के टुकड़े के onActivityResult कभी नहीं कहा जाता है क्या होगा।

समाधान:

1) नीचे दिए गए कोड के अनुसार अपने फ्रेगमेंट में इरादे शुरू करें:

       /** Pass your fragment reference **/
       frag.startActivityForResult(intent, REQUEST_CODE); // REQUEST_CODE = 12345

2) अब आपके पैरेंट एक्टिविटी में ओवरराइड **onActivityResult() : **

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

इसे काम करने के लिए आपको पेरेंट एक्टिविटी में कॉल करना होगा।

3) अपने खंड कॉल में:

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == Activity.RESULT_OK) {

       }
}

बस। इस समाधान के साथ, इसे किसी भी एक टुकड़े के लिए लागू किया जा सकता है चाहे वह घोंसला हो या नहीं। और हाँ, इसमें सभी मामले शामिल हैं! इसके अलावा, कोड भी अच्छे और साफ हैं।

Comments

मैं 'गतिविधि' के साथ सिस्टम के इरादे का अनुरोध कर रहा था, मुझे सिर्फ खंड के संदर्भ का उपयोग करना था।

— उज़ैर

Answer 8

MANEST NESTED FRAGMENTS के लिए (उदाहरण के लिए, जब एक टुकड़े में एक ViewPager का उपयोग करते हुए)

आपकी मुख्य गतिविधि में :

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

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

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    for (Fragment fragment : getChildFragmentManager().getFragments()) {
        fragment.onActivityResult(requestCode, resultCode, data);
    }
}

अपने घोंसले के टुकड़े में

कॉल गतिविधि

getParentFragment().startActivityForResult(intent, uniqueInstanceInt);

uniqueInstanceInt - इसे ऐसे इंट के साथ बदलें जो नेस्टेड टुकड़ों के बीच अद्वितीय है ताकि एक और टुकड़े को रोकने के लिए जवाब का इलाज किया जा सके।

प्रतिक्रिया प्राप्त करें

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == uniqueInstanceInt ) {
        // TODO your code
    }
}

ध्यान

0 और 65536 के बीच की एक संख्या का उपयोग यूनीकइंस्टेंसेंस में किया जाना चाहिए। त्रुटि से बचने के लिए "अनुरोध के लिए केवल 16 बिट्स का उपयोग कर सकते हैं"।

Comments

गतिविधि

— ऑलेक्ज़ेंडर फिरोजव

Answer 9

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

होस्टिंग गतिविधि के लिए, यदि नहीं तो कोई भी इतिहास प्रॉपर्टी को गलत न निर्धारित करें

android:noHistory="false"

गतिविधि शुरू होने के लिए, लॉन्च मोड को मानक के रूप में सेट करें यदि है

android:launchMode="standard"

Answer 10

मैं भी एक बार मैं एक के कोड के बाहर के इस खंड को स्थानांतरित कर दिया एक ही समस्या का सामना करना पड़ रहा था टुकड़ा एक करने के लिए उपयोगिता कक्षा के साथ, parentActivityके रूप में पारित तर्क ,

Intent intent = new Intent(parentActivity, CameraCaptureActivity.class);
parentActivity.startActivityForResult(intent,requestCode);

तब मुझे onActivityResultउस Fragment की विधि में कोई मूल्य नहीं मिल रहा था , बाद में, मैंने इस तर्क को Fragment में बदल दिया , इसलिए विधि की संशोधित परिभाषा इस तरह दिखी,

Intent intent = new Intent(fragment.getContext(), CameraCaptureActivity.class);
fragment.startActivityForResult(intent,requestCode);

उसके बाद, मैं फ्रैगमेंटonActivityResult पर मूल्य प्राप्त करने में सक्षम था

Answer 11

मैं इस समस्या को एक खंड में भी मिला था। और मैं कहा जाता है startActivityForResultएक में DialogFragment।

लेकिन अब इस समस्या का समाधान हो गया है
FragmentClassname.this.startActivityForResult :।

Comments

महान, मेरे लिए काम किया, क्योंकि मैं startActivityForResult(...)खंड के कोड के अंदर एक अमूर्त वर्ग से बुला रहा था ।

— विंस

Answer 12

NESTED FRAGMENTS के लिए (उदाहरण के लिए, जब ViewPager का उपयोग करते हुए)

आपकी मुख्य गतिविधि में:

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

आपके मुख्य शीर्ष स्तर के टुकड़े में (ViewPager टुकड़ा):

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    YourFragment frag = (YourFragment) getChildFragmentManager().getFragments().get(viewPager.getCurrentItem());
    frag.yourMethod(data);  // Method for callback in YourFragment
    super.onActivityResult(requestCode, resultCode, data);
}

YourFragment में (नेस्टेड टुकड़ा):

public void yourMethod(Intent data){
    // Do whatever you want with your data
}

Answer 13

मेरे मामले में यह एक एंड्रॉइड बग था ( http://technet.weblineindia.com/mobile/onactivityresult-not-getting-called-in-nested-fragments-android/ ), यदि आप इसका FragmentActivityउपयोग getSupportFragmentManagerकरने के लिए उपयोग करने के लिए आपको इसका उपयोग करने का समर्थन करते हैं getChildFragmentManager:

List<Fragment> fragments = getSupportFragmentManager().getFragments();
if (fragments != null) {
    for (Fragment fragment : fragments) {
        if(fragment instanceof UserProfileFragment) {
            fragment.onActivityResult(requestCode, resultCode, data);
        }
    }
}

Answer 14

संक्षेप में,

टुकड़े टुकड़े में, घोषित करें Fragment fragment = this;

इसके बाद उपयोग करें fragment.startActivityForResult।

परिणाम गतिविधि में वापस आ जाएगा।

Answer 15

समाधान 1:

के startActivityForResult(intent, REQUEST_CODE);बजाय कॉल करें getActivity().startActivityForResult(intent, REQUEST_CODE);।

समाधान 2:

जब startActivityForResult(intent, REQUEST_CODE);गतिविधि onActivityResult(requestCode,resultcode,intent)को बुलाया जाता है, और तब आप fragments onActivityResult()यहां से कॉल कर सकते हैं, पासिंग requestCode, resultCode and intent।

Answer 16

अपने टुकड़े के अंदर, कॉल करें

this.startActivityForResult(intent, REQUEST_CODE);

जहां thisटुकड़े का जिक्र है। अन्यथा @Clevester ने कहा:

Fragment fragment = this;
....
fragment.startActivityForResult(intent, REQUEST_CODE);

मुझे भी बुलाना था

super.onActivityResult(requestCode, resultCode, data);

माता-पिता की गतिविधियों में onActivityResultयह काम करने के लिए।

(मैंने @ Clevester के उत्तर से इस उत्तर को अनुकूलित किया।)

Answer 17

जो लोग उपयोग एंड्रॉयड नेविगेशन घटक गतिविधि के दशक में इस्तेमाल करना चाहिए यह टुकड़ा संदर्भ और कॉल टुकड़ा का है पाने के लिए ।onActivityResult(...)primaryNavigationFragmentfragment.onActivityResult(...)

यहाँ गतिविधि है onActivityResult(...)

@Override
public void onActivityResult(int requestCode, int resultCode, Intent imageData)
{
    super.onActivityResult(requestCode, resultCode, imageData);

    for (Fragment fragment : getSupportFragmentManager().getPrimaryNavigationFragment().getChildFragmentManager().getFragments())
    {
            fragment.onActivityResult(requestCode, resultCode, imageData);
    }
}

Answer 18

इनमें से अधिकांश उत्तर यह कहते रहते हैं कि आपको super.onActivityResult(...)अपने मेजबान के Activityलिए कॉल करना होगा Fragment। लेकिन वह मेरे लिए काम नहीं करता था।

इसलिए, अपने मेजबान में Activityआपको अपने Fragments onActivityResult(...)बजाय कॉल करना चाहिए । यहाँ एक उदाहरण है।

public class HostActivity extends Activity {

    private MyFragment myFragment;

    protected void onActivityResult(...) {
        super.onActivityResult(...);
        this.myFragment.onActivityResult(...);
    }
}

आपके कुछ बिंदु पर HostActivityआपको यह निर्दिष्ट करने की आवश्यकता होगी this.myFragmentकि Fragmentआप उपयोग कर रहे हैं। या, इसे अपने संदर्भ में रखने FragmentManagerके Fragmentबजाय प्राप्त करने के लिए उपयोग करें HostActivity। इसके अलावा, nullकॉल करने का प्रयास करने से पहले जांच लें this.myFragment.onActivityResult(...);।

Answer 19

public class takeimage extends Fragment {

    private Uri mImageCaptureUri;
    private static final int PICK_FROM_CAMERA = 1;
    private static final int PICK_FROM_FILE = 2;
    private String mPath;
    private ImageView mImageView;
    Bitmap bitmap = null;
    View view;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        view = inflater.inflate(R.layout.activity_send_image, container, false);
        final String[] items = new String[] { "From Camera", "From SD Card" };
        mImageView = (ImageView)view.findViewById(R.id.iv_pic);
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(), android.R.layout.select_dialog_item, items);
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle("Select Image");

        builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int item) {
                if (item == 0) {
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    File file = new File(Environment.getExternalStorageDirectory(), "tmp_avatar_"
                        + String.valueOf(System.currentTimeMillis())
                        + ".jpg");
                    mImageCaptureUri = Uri.fromFile(file);

                    try {
                        intent.putExtra(
                            android.provider.MediaStore.EXTRA_OUTPUT,
                            mImageCaptureUri);
                        intent.putExtra("return-data", true);

                        getActivity().startActivityForResult(intent,
                            PICK_FROM_CAMERA);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    dialog.cancel();
                } else {
                    Intent intent = new Intent();

                    intent.setType("image/*");
                    intent.setAction(Intent.ACTION_GET_CONTENT);

                    getActivity().startActivityForResult(
                        Intent.createChooser(intent,
                            "Complete action using"), PICK_FROM_FILE);
                }
            }
        });
        final AlertDialog dialog = builder.create();

        Button show = (Button) view.findViewById(R.id.btn_choose);
        show.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // Switch the tab content to display the list view.
                dialog.show();
            }
        });

    return view;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {

        if (resultCode != Activity.RESULT_OK)
            return;

        if (requestCode == PICK_FROM_FILE) {
            mImageCaptureUri = data.getData();
            // mPath = getRealPathFromURI(mImageCaptureUri); //from Gallery

            if (mPath == null)
                mPath = mImageCaptureUri.getPath(); // from File Manager

            if (mPath != null)
                bitmap = BitmapFactory.decodeFile(mPath);
        } else {
            mPath = mImageCaptureUri.getPath();
            bitmap = BitmapFactory.decodeFile(mPath);
        }
        mImageView.setImageBitmap(bitmap);  
    }

    public String getRealPathFromURI(Uri contentUri) {
        String [] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = managedQuery(contentUri, proj, null, null,null);

        if (cursor == null) return null;

        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    }
} 

Answer 20

1. आप बस onActivityResultटुकड़े पर BaseActivity को ओवरराइड कर सकते हैं baseActivity.startActivityForResult।

2. BaseActivity पर इंटरफ़ेस जोड़ें और onActivityResult को ओवरराइड करें।

   private OnBaseActivityResult baseActivityResult;
   public static final int BASE_RESULT_RCODE = 111;
   public interface OnBaseActivityResult{
       void onBaseActivityResult(int requestCode, int resultCode, Intent data);
      }
   }
   
   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
   super.onActivityResult(requestCode, resultCode, data);
   if(getBaseActivityResult() !=null && requestCode == BASE_RESULT_RCODE){
       getBaseActivityResult().onBaseActivityResult(requestCode, resultCode, data);
       setBaseActivityResult(null);
   }

3. सुगंध लागू होने पर OnBaseActivityResult

   @Override
   public void onBaseActivityResult(int requestCode, int resultCode, Intent data) {
   Log.d("RQ","OnBaseActivityResult");
   if (data != null) {
       Log.d("RQ","OnBaseActivityResult + Data");
       Bundle arguments = data.getExtras();
     }
   }

यह वर्कअराउंड ट्रिक करेगा।

Answer 21

यदि उपरोक्त समस्या फेसबुक लॉगिन पर आती है तो आप नीचे दिए कोड का उपयोग अपनी खंड की मूल गतिविधि में कर सकते हैं जैसे:

Fragment fragment = getFragmentManager().findFragmentById(android.R.id.tabcontent);
fragment.onActivityResult(requestCode, resultCode, data);

या:

Fragment fragment = getFragmentManager().findFragmentById("fragment id here");
fragment.onActivityResult(requestCode, resultCode, data);

और अपने टुकड़े में नीचे कॉल जोड़ें ...

callbackManager.onActivityResult(requestCode, resultCode, data);

Answer 22

एक अन्य उपयोग मामला पहले से ही अन्य उत्तरों में वर्णित नहीं है:

onActivityResult()उपयोग करते समय खंड में घोषित नहीं किया गया है exception.startResolutionForResult():

if (exception is ResolvableApiException) {
    exception.startResolutionForResult(activity!!, MY_REQUEST_CODE)
}

इस मामले exception.startResolutionForResult()में टुकड़े के साथ बदलें startIntentSenderForResult():

if (exception is ResolvableApiException) {
    startIntentSenderForResult(exception.resolution.intentSender, MY_REQUEST_CODE, null, 0, 0, 0, null)
}

Answer 23

कोटलिन संस्करण (आपकी गतिविधि में onActivityResult ())

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    //add following lines in your activity
    if(supportFragmentManager?.fragments!=null && supportFragmentManager?.fragments!!.size>0)
     for (i in 0..supportFragmentManager?.fragments!!.size-1) {
         val fragment= supportFragmentManager?.fragments!!.get(i)
         fragment.onActivityResult(requestCode, resultCode, data)
    }
 }

Answer 24

जैसा कि ओली सी ने उल्लेख किया है, जब आप नेस्टेड टुकड़ों का उपयोग कर रहे हैं, तो onActivityResult को लौटाए गए मूल्यों का उपयोग करके समर्थन लाइब्रेरी के लिए एक सक्रिय बग है। मैंने बस इसे मारा :-(

Fragment.onActivityResult देखें जब अनुरोध नहीं किया जाता है! = 0 ।

Answer 25

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

टुकड़ा की युक्त गतिविधि से कॉल startActivityForResult (इरादे, int)।

देखें: Android Fragment API

इसलिए, यह प्रतीत होता है कि सबसे सही और विश्वसनीय दृष्टिकोण वास्तव में कॉल करने के लिए किया जाएगा startActivityForResult () की मेजबानी गतिविधि से और भी जिसके परिणामस्वरूप संभाल onActivityResult () वहाँ से।

Comments

मुझे नहीं लगता कि "कॉल स्टार्टअक्टिविटी फ़ॉर एक्टिविटी फ्रॉम एक्टिविटी" एक सिफारिश है। यदि आप फ्रैगमेंट बेस क्लास के अंदर कार्यान्वयन को देखते हैं, तो यह सब होता है mActivity.startActivityFromFragment(this, intent, requestCode)- इसलिए यह एक और कुछ नहीं बल्कि एक सुविधा आवरण है

— एंटी वीराना

Answer 26

आपके कोड में एक नेस्टेड टुकड़ा है। कॉलिंग super.onActivityForResult काम नहीं करता है

आप हर उस गतिविधि को संशोधित नहीं करना चाहते हैं जिसे आपके टुकड़े से बुलाया जा सकता है और खंड टुकड़े श्रृंखला में हर टुकड़े को कॉल करने के आसपास काम कर सकता है।

यहाँ कई कार्य समाधानों में से एक है। मक्खी पर एक टुकड़ा बनाएँ और समर्थन टुकड़ा प्रबंधक के साथ सीधे गतिविधि के लिए इसे तार। फिर startActivityForResult को नए बनाए गए टुकड़े से कॉल करें।

private void get_UserEmail() {

    if (view == null) {
        return;
    }
    ((TextView) view.findViewById(R.id.tvApplicationUserName))
            .setText("Searching device for user accounts...");

    final FragmentManager fragManager = getActivity().getSupportFragmentManager();

    Fragment f = new Fragment() {
        @Override
        public void onAttach(Activity activity) {
            super.onAttach(activity);
            startActivityForResult(AccountPicker.newChooseAccountIntent(null, null,
                    new String[]{"com.google"}, false, null, null, null, null), REQUEST_CODE_PICK_ACCOUNT);
        }

        @Override
        public void onActivityResult(int requestCode, int resultCode,
                                     Intent data) {
            if (requestCode == REQUEST_CODE_PICK_ACCOUNT) {
                String mEmail = "";
                if (resultCode == Activity.RESULT_OK) {
                    if (data.hasExtra(AccountManager.KEY_ACCOUNT_NAME)) {
                        mEmail = data
                                .getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
                    }
                }
                if (mActivity != null) {
                    GoPreferences.putString(mActivity, SettingApplication.USER_EMAIL, mEmail);
                }
                doUser();
            }
            super.onActivityResult(requestCode, resultCode, data);
            fragManager.beginTransaction().remove(this).commit();
        }
    };
    FragmentTransaction fragmentTransaction = fragManager
            .beginTransaction();
    fragmentTransaction.add(f, "xx" + REQUEST_CODE_PICK_ACCOUNT);
    fragmentTransaction.commit();
}

Comments

यह वास्तव में काम करता है और मुझे इसके लिए केवल एक वोट मिला है। मक्खी पर एक टुकड़ा बनाएँ। बहुत आसान है लेकिन इसका सही काम समाधान है। किसी ने मेरे लिए इसे संपादित करने की भी कोशिश की।

— danny117

Answer 27

मेरी समस्या मेजबान गतिविधि के साथ थी, मैंने इसे एक सेट के साथ पाया android:launchMode="standard"मैंने इसे एक अस्थायी काम से हटा दिया!

Answer 28

एक बिंदु किसी के पास नहीं है mentionकि सुनिश्चित करें कि आपके होस्ट गतिविधि लॉन्च मोड को सेट नहीं करना चाहिए singleInstanceया नहीं singleTask।

onActivityResult तब काम नहीं करेगा जब आपका लॉन्च मोड SingleInstance या SingleTask पर सेट हो। या आप इन IntentFilters का उपयोग करके अपनी गतिविधि कहते हैं

standardया singleTopलॉन्च मोड ठीक काम करेगा।

Answer 29

यदि आप नेस्टेड टुकड़े का उपयोग कर रहे हैं, तो यह भी काम कर रहा है:

getParentFragment().startActivityForResult(intent, RequestCode);

इसके अलावा, आपको super.onActivityResultमूल गतिविधि से कॉल करना होगा और onActivityResultटुकड़े की विधि को भरना होगा ।

Answer 30

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