onActivityResult කැබැල්ලෙන් කැඳවනු නොලැබේ

onActivityResultකැමරාවේ ක්‍රියාකාරිත්වය නැවත පැමිණෙන විට මෙම කැබැල්ල සත්කාරකත්වය දක්වන ක්‍රියාකාරකම කැඳවනු ලැබේ.

මගේ කැබැල්ල කැමරාවක් පින්තූරයක් ගැනීමට යවන ලද අභිප්‍රාය ඇතිව ප්‍රති result ලයක් සඳහා ක්‍රියාකාරකමක් ආරම්භ කරයි. පින්තූර යෙදුම හොඳින් පටවා, පින්තූරයක් ගෙන නැවත පැමිණේ. මෙම 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);
    }
}

සත්කාරක ක්‍රියාකාරකම් අභිබවා යයි onActivityResult(), නමුත් එය පාලනය super.onActivityResult()නොකළ ප්‍රති result ල කේත සඳහා ඇමතුමක් ලබා දුන්නේ නැත . පෙනෙන විදිහට, startActivityForResult()ඇමතුම ලබා දෙන්නේ කැබැල්ල වුවද , ක්‍රියාකාරකමට ප්‍රති shot ලය හැසිරවීමේ පළමු වෙඩි මුරය ලැබේ. කොටස්වල මොඩියුලරිටි බව ඔබ සලකන විට මෙය අර්ථවත් කරයි. super.onActivityResult()සියලු පාලනයකින් තොර ප්‍රති results ල සඳහා මා ක්‍රියාත්මක කළ පසු , එම කොටස ප්‍රති the ල හැසිරවීමේදී වෙඩි තබා ඇත.

Iqiqing පිළිතුරෙන්:

ඔබේ කැබැල්ලේ ප්‍රති result ලය ලබා ගැනීම සඳහා ඔබේ කැබැල්ල ඇතුළත startActivityForResult(intent,111);වෙනුවට ඇමතීමට වග බලා ගන්න getActivity().startActivityForResult(intent,111);.

මම හිතන්නේ ඔයා කතා කලා getActivity().startActivityForResult(intent,111);. ඔබ ඇමතිය යුතුයි startActivityForResult(intent,111);.

විකල්ප 1:

ඔබ කෑල්ලෙන් අමතන්නේ startActivityForResult()නම්, ඔබ ඇමතිය යුතුය startActivityForResult(), එසේ නොවේ getActivity().startActivityForResult(), එහි ප්‍රති result ලය වනුයේ onActivityResult ().

ඔබ අමතන්නේ කොතැනටද startActivityForResult()සහ ඔබ ඇමතුම් ක්‍රම කරන්නේ කෙසේදැයි ඔබට විශ්වාස නැත්නම්.

විකල්ප 2:

ක්රියාකාරකම් ප්රතිඵලයක් ලැබෙන බැවින් onActivityResult(), ඔබ ක්රියාකාරකම් ගේ ප්රතිස්ථාපනය කිරීමට අවශ්ය වනු ඇත onActivityResult()හා කතා super.onActivityResult()unhandled ප්රතිඵල කේත සඳහා හෝ සියලු සඳහා අදාළ බිඳී යන්න ප්රචාරය කිරීමට.

ඉහත විකල්ප දෙකක් ක්‍රියා නොකරන්නේ නම්, එය අනිවාර්යයෙන්ම ක්‍රියාත්මක වන බැවින් 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
}

ඔබගේ ක්‍රියාකාරකමේ කොටස් ඔබ නොදන්නේ නම්, ඒවා සියල්ලම ගණනය කර ක්‍රියාකාරකම් ප්‍රති result ල තර්ක යවන්න:

// 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);
    }
}

මට මේ හා සමාන ගැටලුවක් තිබේ ChildFragmentManager. කළමනාකරු විසින් කූඩුව කැබැල්ලට ප්‍රති result ලය ලබා නොදෙනු ඇත, ඔබ එය ඔබේ මූලික කැබැල්ලේ අතින් කළ යුතුය.

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);
    }
}

මුල් තනතුර.

FragmentActivityrequestCodeනවීකරණය කරන ලද එකක් මගින් ප්‍රතිස්ථාපනය කරයි . ඊට පසු, onActivityResult()ආයාචනා කරන විට, FragmentActivityඉහළ බිටු 16 විග්‍රහ කර මුල් කැබැල්ලේ දර්ශකය ප්‍රතිස්ථාපනය කරයි. මෙම යෝජනා ක්රමය දෙස බලන්න:

ඔබට මූල මට්ටමින් කොටස් කිහිපයක් තිබේ නම් ගැටළු නොමැත. නමුත් ඔබට කැදැලි කැබලි තිබේ නම් , උදාහරණයක් ලෙස Fragmentඇතුළත ටැබ් කිහිපයක් සමඟ, ගැටලුවකට මුහුණ දෙන බවටViewPager ඔබ සහතික විය (හෝ දැනටමත් එයට මුහුණ දී ඇත).

නිසා එක දර්ශකය තුළ ගබඩා කර ඇත requestCode. එය Fragmentඑහි ඇතුළත දර්ශකයයි FragmentManager. අපි කැදැලි කැබලි භාවිතා කරන විට FragmentManager, ඔවුන්ගේම කොටස් ලැයිස්තුවක් ඇති ළමා s ඇත. එබැවින්, මුල සිට ආරම්භ වන සමස්ත දර්ශක දාමය සුරැකීම අවශ්‍ය වේ FragmentManager.

අපි මෙම ගැටළුව විසඳන්නේ කෙසේද? මෙම ලිපියේ පොදු විසඳුම් විසඳුමක් ඇත .

GitHub: https://github.com/shamanland/nested-fragment-issue

මෙය වඩාත් ජනප්‍රිය කාරණයකි. මෙම ගැටළුව සම්බන්ධයෙන් අපට නූල් ගොඩක් සොයාගත හැකිය. නමුත් ඒ කිසිවක් මට ප්‍රයෝජනවත් නොවේ.

එබැවින් මම මෙම විසඳුම භාවිතා කරමින් මෙම ගැටළුව විසඳා ඇත.

මෙය සිදුවන්නේ මන්දැයි පළමුව තේරුම් ගනිමු.

අපට startActivityForResultකෙලින්ම ෆ්‍රැග්මන්ට් වෙතින් ඇමතිය හැකි නමුත් ඇත්ත වශයෙන්ම පිටුපස කාර්මිකයා සියල්ලම හසුරුවනු ලබන්නේ ක්‍රියාකාරකම් මගිනි.

ඔබ ඇමතූ පසු startActivityForResult කැබැල්ලකින් ඇමතූ , ෆ්‍රැග්මන්ට්ගේ අනන්‍යතාවය කේතයට අනුයුක්ත කිරීම සඳහා ඉල්ලීම් කේතය වෙනස් වේ. ප්‍රති result ලය ලැබුණු පසු මෙම ඉල්ලීම යවන අයව සොයා ගැනීමට ක්‍රියාකාරකමට එය ඉඩ දෙයි.

ක්‍රියාකාරකම් නැවත සැරිසැරූ පසු, ප්‍රති result ලය නවීකරණය කරන ලද ඉල්ලීම් කේතය සමඟ ක්‍රියාකාරීත්වයේ ක්‍රියාකාරීත්වයට යවනු ලබන අතර එය මුල් ඉල්ලීම් කේතය + කැබැල්ලේ අනන්‍යතාවයට විකේතනය වේ. ඊට පසු, ක්‍රියාකාරකම් මඟින් එම කොටස වෙත ක්‍රියාකාරකම් ප්‍රති ult ලය onActivityResult හරහා යවනු ලැබේ. ඒ සියල්ල අවසන්.

ගැටලුව වන්නේ:

ක්‍රියාකාරකමට ප්‍රති result ලය යැවිය හැක්කේ ක්‍රියාකාරකමට කෙලින්ම අමුණා ඇති කැබැල්ලට පමණි. 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) {

       }
}

ඒක තමයි. මෙම ද්‍රාවණය සමඟ එය කැදැල්ල හෝ නැතත් ඕනෑම තනි කැබැල්ලකට යෙදිය හැකිය. ඔව්, එය ද සියලු නඩුව ආවරණය කරයි! එපමණක් නොව, කේත ද ලස්සන හා පිරිසිදු ය.

බොහෝ නෙස්ටඩ් ෆ්‍රැග්මන්ට්ස් සඳහා (නිදසුනක් ලෙස, කැබැල්ලක වීව් පේජර් භාවිතා කරන විට)

ඔබගේ ප්‍රධාන ක්‍රියාකාරකම තුළ :

@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 - තවත් කැබැල්ලක් පිළිතුරට සැලකීම වැළැක්වීම සඳහා එය කොටස් අතර අද්විතීය වූ int සමඟ ආදේශ කරන්න.

ප්‍රතිචාරය ලබා ගන්න

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

අවධානය

0 සිට 65536 අතර සංඛ්‍යාවක් අද්විතීය ඉන්ස්ටැන්ස් හි භාවිතා කිරීම අවශ්‍ය වේ.

යමෙකුට තවමත් එය කළ නොහැකි නම් මට උපදෙස් දෙකක් එකතු කළ හැකිය. Manifest.xml ගොනුවේ, නැවත ඇමතුමේදී සත්කාරක ක්‍රියාකාරකම් අවසන් නොවූ බවට වග බලා ගන්න සහ ආරම්භ කළ යුතු ක්‍රියාකාරකම් දියත් කිරීමේ ප්‍රකාරය සම්මත ලෙස ඇත. පහත විස්තර බලන්න:

සත්කාරක ක්‍රියාකාරකම් සඳහා, ඉතිහාස දේපල කිසිවක් නොමැති නම් අසත්‍ය ලෙස සකසන්න

android:noHistory="false"

ක්‍රියාකාරකම් ආරම්භ කිරීම සඳහා, දියත් කිරීමේ මාතය තිබේ නම් සම්මත ලෙස සකසන්න

android:launchMode="standard"

මම ද එම ප්රශ්නය මම සංග්රහය පිටත මෙම වාරණ මාරු වරක් මුහුණ දී ඛණ්ඩවල වෙත උපයෝගිතා පන්තියේ සමග parentActivityසම්මත තර්කය ,

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

එවිට මම කිසි වටිනාකමක් ලබා නැත onActivityResultඒ ක්රමය ඛණ්ඩවල , ඉන් පසුව, මම වෙනස් තර්කය කිරීමට ඛණ්ඩවල , ඒ නිසා ක්රමය සංශෝධනය කරන අර්ථ දැක්වීම වගේ,

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

ඊට පසු, මම අගය ලබා ගැනීමට සමත් විය onActivityResultමත ඛණ්ඩවල

මටත් මේ ගැටලුව හමු වුණේ කැබැල්ලක. මම startActivityForResultඅ DialogFragment.

නමුත් දැන් මෙම ගැටළුව විසඳී ඇත :
FragmentClassname.this.startActivityForResult .

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
}

මගේ නඩුවේ එය ඇන්ඩ්‍රොයිඩ් දෝෂයකි ( http://technet.weblineindia.com/mobile/onactivityresult-not-getting-called-in-nested-fragment-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);
        }
    }
}

භාවිතා කරන අය සඳහා ඇන්ඩ්රොයිඩ් Navigation සංරචකය ක්රියාකාරකම් ගණන්වල භාවිතා කළ යුතු onActivityResult(...)වන primaryNavigationFragmentඑය කැබැල්ලක් සමුද්දේශ සහ ඇමතුමක් කැබැල්ලක් ගේ තියෙන්නේ ලබා ගැනීමට fragment.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);
    }
}

කෙටියෙන්,

කැබැල්ලෙන්, ප්රකාශ කරන්න Fragment fragment = this;

එම භාවිතයෙන් පසුව fragment.startActivityForResult.

ප්‍රති result ලය ක්‍රියාකාරී ප්‍රති in ලයෙන් නැවත ලැබෙනු ඇත.

විසඳුම 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.

ඔබේ කැබැල්ල ඇතුළත අමතන්න

this.startActivityForResult(intent, REQUEST_CODE);

කොහෙද thisකැබැල්ලට යොමු වන්නේ. Le ක්ලෙස්ටර් පැවසූ පරිදි කරන්න:

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

මටත් කතා කරන්න සිද්ධ වුණා

super.onActivityResult(requestCode, resultCode, data);

මව් ක්‍රියාකාරකම් තුළ onActivityResultඑය ක්‍රියාත්මක කිරීමට.

(මම මෙම පිළිතුර අනුවර්තනය කළේ @ ක්ලෙවෙස්ටර්ගේ පිළිතුරෙනි.)

එම පිළිතුරු බොහෝ ඔයාට කතා කිරීමට ඇති බව පවසමින් තබා 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(...);.

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);
    }
} 

1. ඔබට හුදෙක් කැබැල්ල onActivityResultමත පදනම් ක්‍රියාකාරිත්වය අභිබවා යා හැකිය 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();
     }
   }

මෙම ක්‍රියාමාර්ගය උපක්‍රමය කරනු ඇත.

ෆේස්බුක් පිවිසුමේදී ඉහත ගැටලුවට මුහුණ දී ඇත්නම්, පහත දැක්වෙන කේතය ඔබේ කැබැල්ලේ මව් ක්‍රියාකාරකම් වලදී භාවිතා කළ හැකිය:

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);

මෝහිත් මේතාගේ පිළිතුරෙන් ආනුභාව ලත් ඇන්ඩ්‍රොයිඩ් සංචාලන සංරචකය භාවිතා කරන්නන් සඳහා කොට්ලින් අනුවාදය

 override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    supportFragmentManager.primaryNavigationFragment?.childFragmentManager?.fragments?.forEach { fragment ->
        fragment.onActivityResult(requestCode, resultCode, data)
    }
}

වෙනත් පිළිතුරු වල දැනටමත් විස්තර කර නොමැති තවත් භාවිත නඩුවක්:

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)
}

කෝට්ලින් අනුවාදය (ක්‍රියාකාරීත්වයේ ප්‍රති ult ල () හි ඔබගේ ක්‍රියාකාරකම් වලදී)

 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)
    }
 }

සමග ඇන්ඩ්රොයිඩ් ගමන් මඟ අංගයක් , මෙම ගැටලුව, ඔබ පිළිතුරු පැතැලිව කොටස් ඇති වූ විට , ඉතා unsolvable අභිරහස වගේ දැනෙනවා විය.

මෙම ලිපියේ පහත දැක්වෙන පිළිතුරු වලින් ලද දැනුම හා ආනුභාවය මත පදනම්ව, සරල විසඳුමක් සකස් කිරීමට මට හැකි විය:

• මෙම ලිපියෙන් පිළිතුරු දෙන්න
• මෙම ලිපියෙන් පිළිතුරු දෙන්න

ඔබගේ ක්රියාකාරකම් ගණන්වල onActivityResult(), ඔබ භාවිතා පැමිණෙන බව ක්රියාකාරී කොටස් ලැයිස්තුව පුඩුවක් හැකි FragmentManagerගේ getFragments()ක්රමය.

මෙය සිදු කිරීම සඳහා ඔබ භාවිතා කළ යුතු බව කරුණාවෙන් සලකන්නgetSupportFragmentManager() ඒපී 26 සහ ඊට ඉහළින් ඉලක්කගත API හෝ .

මෙහි අදහස නම්, ලැයිස්තුවේ එක් එක් කැබැල්ලේ නිදර්ශන වර්ගය පරික්ෂා කරමින් ලැයිස්තුව හරහා ලූප කිරීමයි instanceof.

වර්ගය මෙම ලැයිස්තුව හරහා ප්රහාරක අතර Fragmentවඩාත් සුදුසු ය, අවාසනාවකට මෙන්, ඔබ ඇන්ඩ්රොයිඩ් Navigation සංරචකය මගින් කරන විට, ලැයිස්තුව පමණක් එක් භාණ්ඩයක්, එනම්, ඇත NavHostFragment.

ඉතින් දැන් මොකක්ද? අපි කොටස් දැනගත යුතුයි NavHostFragment. NavHostFragmentඑයම කැබැල්ලකි. එබැවින් භාවිතා කිරීමෙන් getChildFragmentManager().getFragments(), අප නැවත වරක් අප List<Fragment>දන්නා කොටස් කැබලි ලබා ගනී NavHostFragment. අපි instanceofඑක් එක් කැබැල්ල පරීක්ෂා කරමින් එම ලැයිස්තුව හරහා ලූපයෙමු.

ලැයිස්තුවේ ඇති අපගේ උනන්දුව දක්වන කොටස සොයාගත් පසු, අපි එය හඳුන්වන්නේ onActivityResult(), ක්‍රියාකාරකම් onActivityResult()ප්‍රකාශ කරන සියලු පරාමිතීන් වෙත ය .

//  Your activity's onActivityResult()

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

        List<Fragment> lsActiveFragments = getSupportFragmentManager().getFragments();
        for (Fragment fragmentActive : lsActiveFragments) {

            if (fragmentActive instanceof NavHostFragment) {

                List<Fragment> lsActiveSubFragments = fragmentActive.getChildFragmentManager().getFragments();
                for (Fragment fragmentActiveSub : lsActiveSubFragments) {

                    if (fragmentActiveSub instanceof FragWeAreInterestedIn) {
                        fragmentActiveSub.onActivityResult(requestCode, resultCode, data);
                    }

                }

            }

        }

    }

ඔලී සී සඳහන් කළ පරිදි, ඔබ කැදැලි කොටස් භාවිතා කරන විට ආධාරක පුස්තකාලය සඳහා සක්‍රීය අගයන් onActivityResult වෙත ලබා දී ඇත. මම එයට පහර දුන්නා :-(.

ඉල්ලීම් කේතය! = 0 විට කැඳවනු නොලැබූ Fragment.onActivityResult බලන්න .

මෙහි ඇති සියලුම පිළිතුරු හක්කවලට වඩා වැඩි දෙයක් නොවන බවට මට දැඩි සැකයක් ඇත. මම ඔවුන් සියල්ලන්ම සහ තවත් බොහෝ අය අත්හදා බැලුවෙමි, නමුත් සෑම විටම යම් ආකාරයක මෝඩ ප්‍රශ්නයක් ඇති බැවින් විශ්වාසදායක නිගමනයකින් තොරව. මට නොගැලපෙන ප්‍රති .ල මත විශ්වාසය තැබිය නොහැක. කොටස් සඳහා නිල ඇන්ඩ්‍රොයිඩ් ඒපීඅයි ප්‍රලේඛනය දෙස බැලුවහොත් ගූගල් පහත සඳහන් දේ පැහැදිලිව සඳහන් කරයි:

කැබැල්ලේ ක්‍රියාකාරිත්වය අඩංගු ආරම්භක ක්‍රියාකාරීත්ව ප්‍රති es ල (අභිප්‍රාය, int) අමතන්න.

බලන්න: Android Fragment API

එබැවින්, වඩාත්ම නිවැරදි හා විශ්වාසදායක ප්‍රවේශය වනුයේ ඇත්ත වශයෙන්ම සත්කාරක ක්‍රියාකාරකමේ සිට ආරම්භක ක්‍රියාකාරීත්ව ප්‍රති es ල () අමතන්න සහ එහි ප්‍රති ing ලයක් ලෙස ක්‍රියාත්මක වන ප්‍රති R ල () එහි සිට හැසිරවීමයි .

ඔබේ කේතයේ කැදැලි කැබැල්ලක් ඇත. 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();
}

මගේ ගැටළුව සත්කාරක ක්‍රියාකාරකම් සමඟ ඇති අතර එය කට්ටලයක් සමඟ android:launchMode="standard"මම එය තාවකාලිකව ඉවත් කර එය වැඩ කරමි!

mentionඔබගේ සත්කාරක ක්‍රියාකාරකම් දියත් කිරීමේ මාදිලිය සකසා නොතිබිය යුතු බවට singleInstanceහෝ කිසිවෙකුටත් නොමැති එක් කරුණක් singleTask.

ඔබේ දියත් කිරීමේ මාදිලිය SingleInstance හෝ SingleTask ලෙස සකසා ඇත්නම් onActivityResult ක්‍රියා නොකරනු ඇත. නැතහොත් ඔබ මෙම ක්‍රියාකාරකම අමතන්නේ මෙම IntentFilters භාවිතා කරමිනි

standardහෝ singleTopදියත් කිරීමේ මාදිලිය හොඳින් ක්‍රියාත්මක වේ.