Android में छिपा हुआ टुकड़ा दिखाएं

Question

मैं एप्लिकेशन विकसित कर रहा हूं जिसमें 2 टुकड़े हैं और मैं अपनी आवश्यकता के अनुसार छिपाना दिखाना चाहता हूं। निम्नलिखित कोड में मेरी समस्या का सरल उदाहरण है। इस साधारण Fragmentactivity में 1 बटन और एक listfragment होता है।

यह सरल उदाहरण निर्दोष काम करता है। लेकिन मैं शो के टुकड़े टुकड़े से संतुष्ट नहीं हूँ। यदि आप लेआउट को हटाते हैं। शुरू करने की योग्यता (View.GONE); कोड से तब ft.hide (f); टुकड़ा नहीं छिपाएगा। वास्तव में हम टुकड़ा नहीं छुपा रहे हैं हम कंटेनर छिपा रहे हैं।

मेरा सवाल यह है कि क्या यह छिपाने के टुकड़े दिखाने का तरीका है? यदि नहीं, तो कृपया परीक्षण किए गए उदाहरण के साथ समझाएं कि फ्रेगमेंट कैसे छिपाएं और दिखाएं क्योंकि बहुत से लोग इस समस्या का सामना कर रहे हैं।

 public class MainActivity extends FragmentActivity implements OnClickListener {

        Fragment1 f;
        Button b;
        LinearLayout layout;
        Fragment myf;
        @Override
        public void onCreate(Bundle savedInstanceState){
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            b = (Button) findViewById(R.id.button1);
            layout = (LinearLayout) findViewById(R.id.ll);
            f = new Fragment1();
        }

        @Override
        public void onClick(View v) {

            FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
            ft.setCustomAnimations(android.R.animator.fade_in, android.R.animator.fade_out);

            if (f.isHidden()) {
                ft.show(f);
                layout.setVisibility(View.VISIBLE);
                b.setText("Hide");
            } else {
                ft.hide(f);
                b.setText("Show");
                layout.setVisibility(View.GONE);
            }
            ft.commit();
            // TODO Auto-generated method stub
        }

Comments

आपको कंटेनर की दृश्यता सेट करने की आवश्यकता क्यों है? यह दृश्यता निर्धारित किए बिना काम करना चाहिए।

— एंड्री चेर्नेंको

वास्तव में यह कंटेनर की दृश्यता के बिना काम करना चाहिए लेकिन इसके काम नहीं कर रहा है। कृपया मेरे साथ सरल कार्य उदाहरण साझा करें। तब मुझे पता चलता कि मैं कहां गायब हूं।

— abidkhan303

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

— एंड्री चेर्नेंको

Answer 1

कंटेनर के दृश्यता झंडे के साथ गड़बड़ न करें - FragmentTransaction.hide / शो आंतरिक रूप से आपके लिए करता है।

तो ऐसा करने का सही तरीका है:

FragmentManager fm = getFragmentManager();
fm.beginTransaction()
          .setCustomAnimations(android.R.animator.fade_in, android.R.animator.fade_out)
          .show(somefrag)
          .commit();

---

या अगर आप android.support.v4.app.Fragment का उपयोग कर रहे हैं

 FragmentManager fm = getSupportFragmentManager();
 fm.beginTransaction()
          .setCustomAnimations(android.R.anim.fade_in, android.R.anim.fade_out)
          .show(somefrag)
          .commit();

Comments

आप सीधे झंडे के साथ खिलवाड़ करने की सलाह क्यों देते हैं? (मैं आपकी सिफारिश पर विवाद नहीं कर रहा हूं, बस इसे समझने की कोशिश कर रहा हूं।)

— एलेन स्पार्टस

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

— एलेन स्पार्टस

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

— अंकन सलाति

@numansalati हाय, वहाँ (समर्थन पुस्तकालय से) का कोई भी संगति ( android.R.animator.fade_inऔर) है android.R.animator.fade_out?

— सोलेस

कंटेनर के साथ, आप इसे SHOW, HIDE या GONE पर सेट कर सकते हैं। एक टुकड़ा छुपाते समय कोई विकल्प नहीं है।

— चुपके रब्बी

Answer 2

व्यसन में, आप एक फ़्रैगमेंट में कर सकते हैं (उदाहरण के लिए जब सर्वर डेटा विफल हो रहा है):

 getView().setVisibility(View.GONE);

Comments

टुकड़ा वस्तु का बच्चा है और नहीं देखें तो कोई कॉल नहीं कर सकता: खंडित होना। विश्वसनीयता (View.INVISIBLE);

— AndroidGeek

Arià कुछ अलग करने का सुझाव दे रहा है, उस टुकड़े से दृश्य प्राप्त करने और उसकी दृश्यता को जाने के लिए निर्धारित करने का सुझाव दे रहा है।

— एल्वारोसिस्टिस्टेबन

सावधान getView()हो सकता है nullजब यह अभी तक आरंभ नहीं किया गया है।

— TWStStrrob

Answer 3

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

// Within an activity
private FragmentA fragmentA;
private FragmentB fragmentB;
private FragmentC fragmentC;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    if (savedInstanceState == null) {
        fragmentA = FragmentA.newInstance("foo");
        fragmentB = FragmentB.newInstance("bar");
        fragmentC = FragmentC.newInstance("baz");
    }
}


// Replace the switch method
protected void displayFragmentA() {
    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
    if (fragmentA.isAdded()) { // if the fragment is already in container
        ft.show(fragmentA);
    } else { // fragment needs to be added to frame container
        ft.add(R.id.flContainer, fragmentA, "A");
    }
    // Hide fragment B
    if (fragmentB.isAdded()) { ft.hide(fragmentB); }
    // Hide fragment C
    if (fragmentC.isAdded()) { ft.hide(fragmentC); }
    // Commit changes
    ft.commit();
}

कृपया अधिक जानकारी के लिए https://github.com/codepath/android_guides/wiki/Creating-and-Using-Fragments देखें । मुझे उम्मीद है कि मुझे किसी की मदद मिलेगी। भले ही यह एक पुराना सवाल हो।

Comments

तो आपके पास दो और तरीके हैं जैसे कि DisplayFragmentB () और displayFragmentC ()?

— तमिरबेक

हां @temirbek आप बस यह प्रदर्शित कर सकते हैं कि प्रदर्शनफ्रेममेंट () पद्धति कैसे लागू की जाती है।

— मग्गू

यदि आपके पास एक गतिविधि (2 या अधिक) में कई टुकड़े हैं और आप उपरोक्त विधि का उपयोग कर रहे हैं, तो कृपया इसका उपयोग करें । इसे लिखना और पढ़ना आसान होगा।

— मैक्सिम क्लाउड

Answer 4

public void showHideFragment(final Fragment fragment){

    FragmentTransaction ft = getFragmentManager().beginTransaction();
    ft.setCustomAnimations(android.R.animator.fade_in,
                    android.R.animator.fade_out);

    if (fragment.isHidden()) {
        ft.show(fragment);
        Log.d("hidden","Show");
    } else {
        ft.hide(fragment);
        Log.d("Shown","Hide");                        
    }

    ft.commit();
}

Comments

सही है ft.setCustomAnimations (android.R.anim.fade_in, android.R.anim.fade_out);

— वेबसर्विस

Answer 5

इसे इस्तेमाल करे:

MapFragment mapFragment = (MapFragment)getFragmentManager().findFragmentById(R.id.mapview);
mapFragment.getView().setVisibility(View.GONE);

Answer 6

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

<LinearLayout style="@style/StHorizontalLinearView"
    >

    <fragment
        android:layout_width="match_parent"
        android:layout_height="390dp"
        android:layout_alignParentTop="true"
        />

</LinearLayout>

Answer 7

इसने मेरे लिए काम किया

FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        if(tag.equalsIgnoreCase("dashboard")){

            DashboardFragment dashboardFragment = (DashboardFragment)
                    fragmentManager.findFragmentByTag("dashboard");
            if(dashboardFragment!=null) ft.show(dashboardFragment);

            ShowcaseFragment showcaseFragment = (ShowcaseFragment)
                    fragmentManager.findFragmentByTag("showcase");
            if(showcaseFragment!=null) ft.hide(showcaseFragment);

        } else if(tag.equalsIgnoreCase("showcase")){
            DashboardFragment dashboardFragment = (DashboardFragment)
                    fragmentManager.findFragmentByTag("dashboard");
            if(dashboardFragment!=null) ft.hide(dashboardFragment);

            ShowcaseFragment showcaseFragment = (ShowcaseFragment)
                    fragmentManager.findFragmentByTag("showcase");
            if(showcaseFragment!=null) ft.show(showcaseFragment);
        }

        ft.commit();

Answer 8

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

public void showHideCardPreview(int id) {
    FragmentManager fm = getSupportFragmentManager();
    Bundle b = new Bundle();
    b.putInt(Constants.CARD, id);
    cardPreviewFragment.setArguments(b);
    FragmentTransaction ft = fm.beginTransaction()
        .setCustomAnimations(android.R.anim.fade_in, android.R.anim.fade_out);
    if (!cardPreviewFragment.isAdded()){
        ft.add(R.id.full_screen_container, cardPreviewFragment);
        ft.show(cardPreviewFragment);
    } else {
        if (cardPreviewFragment.isHidden()) {
            Log.d(TAG,"++++++++++++++++++++ show");
            ft.show(cardPreviewFragment);
        } else {
            Log.d(TAG,"++++++++++++++++++++ hide");
            ft.hide(cardPreviewFragment);
        }
    }

    ft.commit();
} 

Answer 9

final Fragment fragment1 = new fragment1();
final Fragment fragment2 = new fragment2();
final FragmentManager fm = getSupportFragmentManager();
Fragment active = fragment1;

OnCreate में, setContentView के बाद, मैंने दो टुकड़े छिपाए और उन्हें टुकड़ा प्रबंधक के लिए प्रतिबद्ध किया, लेकिन मैंने पहला टुकड़ा नहीं छिपाया जो घर के रूप में काम करेगा।

fm.beginTransaction().add(R.id.main_container, fragment2, "2").hide(fragment2).commit();
fm.beginTransaction().add(R.id.main_container,fragment1, "1").commit();
 @Override
    public void onClick(View v) {
        Fragment another = fragment1;
         if(active==fragment1){
          another = fragment2;
         }
            fm.beginTransaction().hide(active).show(another).commit();
            active = another;
}

रेफरी: https://medium.com/@oluwabukunmi.aluko/bottom-navigation-view-with-fragments-a074bfd08711

Answer 10

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

हमें पहले उन अंशों की एक सूची चाहिए, जिन्हें प्रदर्शित किया जाना चाहिए

public class MainActivity extends AppCompatActivity{
    //...
    List<Fragment> fragmentList = new ArrayList<>();
}

फिर हमें इसे अपने टुकड़ों से भरने की जरूरत है

@Override
protected void onCreate(Bundle savedInstanceState) {
    //...
    HomeFragment homeFragment = new HomeFragment();
    MessagesFragment messagesFragment = new MessagesFragment();
    UserFragment userFragment = new UserFragment();
    FavoriteFragment favoriteFragment = new FavoriteFragment();
    MapFragment mapFragment = new MapFragment();

    fragmentList.add(homeFragment);
    fragmentList.add(messagesFragment);
    fragmentList.add(userFragment);
    fragmentList.add(favoriteFragment);
    fragmentList.add(mapFragment);
}

और हमें यह जानने के लिए एक तरीका चाहिए कि कौन से टुकड़े को सूची से चुना गया था, इसलिए हमें getFragmentIndexफ़ंक्शन की आवश्यकता है

private int getFragmentIndex(Fragment fragment) {
    int index = -1;
    for (int i = 0; i < fragmentList.size(); i++) {
        if (fragment.hashCode() == fragmentList.get(i).hashCode()){
            return i;
        }
    }
    return index;
}

और अंत में, displayFragmentविधि इस तरह होगी:

private void displayFragment(Fragment fragment) {
        int index = getFragmentIndex(fragment);
        FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
        if (fragment.isAdded()) { // if the fragment is already in container
            transaction.show(fragment);
        } else { // fragment needs to be added to frame container
            transaction.add(R.id.placeholder, fragment);
        }
        // hiding the other fragments
        for (int i = 0; i < fragmentList.size(); i++) {
            if (fragmentList.get(i).isAdded() && i != index) {
                transaction.hide(fragmentList.get(i));
            }
        }
        transaction.commit();
    }

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