प्रोग्राम बैकस्टैक में पिछले टुकड़े पर वापस जाएं

Question

कहो कि मेरे पास एक गतिविधि है, जिसके टुकड़े क्रमादेशित हैं:

private void animateToFragment(Fragment newFragment, String tag) {
    FragmentTransaction ft = getFragmentManager().beginTransaction();
    ft.replace(R.id.fragment_container, newFragment, tag);
    ft.addToBackStack(null);
    ft.commit();
}

दिखाई देने वाले पिछले टुकड़े पर लौटने का सबसे अच्छा तरीका क्या है?

मुझे एंड्रॉइड में बटन क्लिक पर ट्रिगर बैक-बटन कार्यक्षमता मिली, लेकिन मैं सोच रहा हूं कि एक बैक की घटना का अनुकरण करना इसके बारे में जाने का सही तरीका नहीं है (और मैं इसे काम करने के लिए भी नहीं प्राप्त कर सकता हूं):

dispatchKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK));

कॉलिंग finish()सिर्फ उस गतिविधि को बंद करती है, जिसमें मुझे कोई दिलचस्पी नहीं है।

क्या इस बारे में जाने का कोई बेहतर तरीका है?

Answer 1

को देखो getFragmentManager().popBackStack()तरीकों (वहाँ से चुनने के लिए कई हैं)

http://developer.android.com/reference/android/app/FragmentManager.html#popBackStack ()

Comments

getFragmentManager().popBackStackImmediate();चाल चली। धन्यवाद।

— आस्की बी।

हालांकि मैं इस विधि को कहाँ रखूँगा? मेरे टैब श्रोता में?

— रासेन ५।

कोड को देखे बिना, यह कहना मुश्किल है ... लेकिन इसे उस कोड के सेक्शन में जाना चाहिए, जिसे आप मौजूदा टुकड़े को "बंद" करना चाहते हैं और पिछले टुकड़े पर लौटना चाहते हैं।

— stuckless

GetSupportFragmentManager () के बारे में क्या

— ViliusK

अपने कोड में "addToBackStack (" टैग ") जोड़ना न भूलें। "। fragmentManager.beginTransaction () की जगह (R.id.content_frame, टुकड़ा) .addToBackStack (" टैग ") प्रतिबद्ध ();।" यदि आप addToBackStack (null) लिखते हैं, तो यह इसे अपने आप संभाल लेगा लेकिन यदि आप कोई टैग देते हैं, तो आपको मैन्युअल रूप से हैंडल करना चाहिए।

— खालिद सैफ

Answer 2

प्रदान किए गए अन्य उत्तरों के बारे में विस्तार से बताने के लिए, यह मेरा समाधान है (एक गतिविधि में रखा गया है):

@Override
public void onBackPressed(){
    FragmentManager fm = getFragmentManager();
    if (fm.getBackStackEntryCount() > 0) {
        Log.i("MainActivity", "popping backstack");
        fm.popBackStack();
    } else {
        Log.i("MainActivity", "nothing on backstack, calling super");
        super.onBackPressed();  
    }
}

Comments

और ऐसा क्यों हो रहा है। टुकड़े के उदाहरण में developer.android.com/training/basics/fragments/index.html वे onbackpressed ईवेंट को ओवरराइड नहीं कर रहे हैं और फिर भी वे फ़्रेग्मेंट बैकस्टैक करने में सक्षम हैं। मैंने trasaction.addToBackStack (नल) का उपयोग किया है; लेकिन कुछ नहीं होता है। क्या आप व्यख्या कर सकते हैं ?

— मुर्तजा खुर्शीद हुसैन

@ मुर्तजा हुसैन से शायद आपको एक नया सवाल पूछना चाहिए अगर आप इसके लिए मदद चाहते हैं। यह देखना थोड़ा कठिन है कि अधिक कोड को देखे बिना क्या चल रहा है।

— काइल फाल्कनर

मेरे मामले में मुझे fm.getBackStackEntryCount() > 1गतिविधि को वापस करने के लिए करना था जब स्टैक में केवल पहला टुकड़ा होता है।

— फेसुंडो ओलानो

एंड्रॉइड पहले से ही आपके लिए ऐसा करता है: "जब बैक स्टैक पर FragmentTransaction ऑब्जेक्ट होते हैं और उपयोगकर्ता बैक बटन दबाता है, तो FragmentManager बैक स्टैक से सबसे हालिया ट्रांजेक्शन को पॉप करता है और रिवर्स एक्शन करता है (जैसे कि एक टुकड़ा निकालते समय) इसे जोड़ा)। " (स्रोत)

— आर्टकॉनिग

Answer 3

जब हम अंशों को अपडेट / जोड़ रहे हैं,

को शामिल करना चाहिए .addToBackStack()।

getSupportFragmentManager().beginTransaction()
    .add(detailFragment, "detail") // Add this transaction to the back stack (name is an optional name for this back stack state, or null).
    .addToBackStack(null)
    .commit();

उसके बाद यदि हम getFragments.popBackStackImmediate()अंशों को जोड़ते / अद्यतन करते हैं, और वर्तमान स्क्रीन पर वापस जाते हैं, तो हम सही रिटर्न देंगे ।

Answer 4

उन लाइन को अपने onBackPressed () मेथड में जोड़ें। popBackStackImmediate () विधि आपको पिछले टुकड़े पर वापस मिल जाएगी यदि आपके पास बैक स्टैक पर कोई टुकड़ा है

if(getFragmentManager().getBackStackEntryCount() > 0){
     getFragmentManager().popBackStackImmediate();
}
else{
    super.onBackPressed();
}

`

Answer 5

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

दूसरी तरफ जब आप द्वितीयक खंड (टुकड़े में टुकड़ा) खोल रहे हैं जो कि मेरे कोड में "डिटेंप्जिदर" के रूप में परिभाषित किया गया है, तो यह प्राथमिक टुकड़ा के पिछले राज्य को वापस कर देगा। चियर्स!

अंदर की गतिविधियों को वापस दबाया जाता है:

Fragment home = getSupportFragmentManager().findFragmentByTag("DetailedPizza");

if (home instanceof FragmentDetailedPizza && home.isVisible()) {
    if (getFragmentManager().getBackStackEntryCount() != 0) {
        getFragmentManager().popBackStack();
    } else {
        super.onBackPressed();
    }
} else {
    //Primary fragment
    moveTaskToBack(true);
}

और इस तरह से अन्य टुकड़ा लॉन्च:

Fragment someFragment = new FragmentDetailedPizza();
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.replace(R.id.container_body, someFragment, "DetailedPizza");
transaction.addToBackStack("DetailedPizza");
transaction.commit();

Answer 6

अगर मेरे पास AddToBackStack () नहीं है, तो ये उत्तर मेरे खंडन लेनदेन में शामिल नहीं होते हैं, लेकिन आप इनका उपयोग कर सकते हैं:

getActivity().onBackPressed();

अपने किसी भी टुकड़े से एक कदम पीछे जाने के लिए;

Answer 7

प्रोग्रामिक रूप से निम्नलिखित कोड का उपयोग करके पिछले टुकड़े पर वापस जाएं।

if ( getFragmentManager().getBackStackEntryCount() > 0) 
{
          getFragmentManager().popBackStack();
          return;
}
super.onBackPressed();

Answer 8

उस टुकड़े को फिर से लाने के लिए, बस उस टुकड़े को बैकस्टैक में जोड़ें जिसे आप बैक प्रेस पर आना चाहते हैं, जैसे:

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Fragment fragment = new LoginFragment();
        //replacing the fragment
        if (fragment != null) {
            FragmentTransaction ft = ((FragmentActivity)getContext()).getSupportFragmentManager().beginTransaction();
            ft.replace(R.id.content_frame, fragment);
            ft.addToBackStack("SignupFragment");
            ft.commit();
        }
    }
});

उपरोक्त मामले में, मैं दबा रहा हूं LoginFragmentजब Button buttonदबाया जाता है, तो अभी उपयोगकर्ता अंदर है SignupFragment। इसलिए, अगर addToBackStack(TAG)कहा जाता है, कहाँ है TAG = "SignupFragment", तो जब बैक बटन दबाया जाता है LoginFragment, तो हम वापस आते हैं SignUpFragment।

हैप्पी कोडिंग!

Comments

मुझे लगता है, TAG प्रभावित नहीं करता है, यह शायद अशक्त भी हो सकता है।

— CoolMind

Answer 9

fragment_tran.addToBackStack(null)पिछले टुकड़े पर जोड़कर , मैं अंतिम टुकड़े पर वापस आने में सक्षम हूं।

नया टुकड़ा जोड़ना :

view.findViewById(R.id.changepass).setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            FragmentTransaction transaction = getActivity().getSupportFragmentManager().beginTransaction();
            transaction.replace(R.id.container, new ChangePassword());
            transaction.addToBackStack(null);
            transaction.commit();
        }
    });

Answer 10

मैं यहां आया था या उसी विचार को देख रहा था, और इस बीच मैं खुद के साथ आया था, जो मुझे लगता है कि यह बुरा नहीं है और अगर ViewPager के साथ काम करता है।

इसलिए मैंने जो किया, वह है पेरेंट एक्टिविटी में ऑनपैकप्रेस्ड मेथड को ओवरराइड करना जो व्यूपेजर को रखता है, और इसे सेट करने के लिए हमेशा माइनस 1 पोजिशन में जाना चाहिए जब तक कि यह पहले टुकड़े तक न पहुंच जाए, फिर एक्टिविटी को बंद कर देता है।

@Override
public void onBackPressed() {
    if(viewPager.getCurrentItem()>0){
        viewPager.setCurrentItem(viewPager.getCurrentItem()-1);
    } else {
        super.onBackPressed();
        this.close();
    }
}

private void close(){
    this.finish();
}

यह एक पतन हो सकता है, जैसे कि यह केवल एक बार वापस चला जाता है हर बार छोड़ दिया जाता है, इसलिए यह बहुत अच्छा काम नहीं कर सकता है अगर टैब हैं और आप पदों को बंद कर छोड़ते हैं, (0 से 2 तक जा रहे हैं, और फिर वापस दबाकर आपको डाल देंगे 1, 0 के बजाय)

मेरे मामले के लिए, टैब के बिना viewPager में 2 टुकड़े के साथ, यह अच्छी तरह से काम करता है।

Comments

इसी तरह के सवाल का जवाब पहले से ही है। stackoverflow.com/questions/10863572/…

— AtifSayings

Answer 11

कोड के नीचे आज़माएं:

@Override
    public void onBackPressed() {
        Fragment myFragment = getSupportFragmentManager().findFragmentById(R.id.container);
        if (myFragment != null && myFragment instanceof StepOneFragment) {
            finish();
        } else {
            if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
                getSupportFragmentManager().popBackStack();
            } else {
                super.onBackPressed();
            }
        }
    }