android - ViewPager और टुकड़े-खंड की स्थिति को स्टोर करने का सही तरीका क्या है?

अगर किसी को अपने FragmentStatePagerAdapter के साथ समस्याएं ठीक से अपने टुकड़ों की स्थिति को पुनर्स्थापित नहीं कर रही हैं ... यानी ... FragmentStatePagerAdapter द्वारा नए Fragments को राज्य से बहाल करने के बजाय बनाया जा रहा है ...

सुनिश्चित करें कि आप ViewPager.setOffscreenPageLimit() कॉल करें, इससे पहले कि आप ViewPager.setAdapeter(fragmentStatePagerAdapter) कॉल करें

ViewPager.setOffscreenPageLimit() को कॉल करने पर ... ViewPager तुरंत इसके एडाप्टर को देखेगा और इसके टुकड़े पाने का प्रयास करेगा। इससे पहले ViewPager को सहेजे गए इंस्टेंसस्टेट से फ्रैगमेंट को पुनर्स्थापित करने का मौका मिलने से पहले ऐसा हो सकता है (इस प्रकार नए टुकड़े बनाते हैं जिन्हें सहेजे गए इंस्टेंसस्टेट से फिर से शुरू नहीं किया जा सकता है क्योंकि वे नए हैं)।

अभिविन्यास परिवर्तन के बाद टुकड़े प्राप्त करने के लिए आपको .getTag () का उपयोग करना होगा।

    getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewPagerId + ":" + positionOfItemInViewPager)

थोड़ी अधिक हैंडलिंग के लिए मैंने अपने पेजएडाप्टर के लिए अपनी खुद की ऐरेलिस्ट लिखी है ताकि किसी भी स्थिति पर ViewPagerId और FragmentClass द्वारा खंड प्राप्त किया जा सके:

public class MyPageAdapter extends FragmentPagerAdapter implements Serializable {
private final String logTAG = MyPageAdapter.class.getName() + ".";

private ArrayList<MyPageBuilder> fragmentPages;

public MyPageAdapter(FragmentManager fm, ArrayList<MyPageBuilder> fragments) {
    super(fm);
    fragmentPages = fragments;
}

@Override
public Fragment getItem(int position) {
    return this.fragmentPages.get(position).getFragment();
}

@Override
public CharSequence getPageTitle(int position) {
    return this.fragmentPages.get(position).getPageTitle();
}

@Override
public int getCount() {
    return this.fragmentPages.size();
}


public int getItemPosition(Object object) {
    //benötigt, damit bei notifyDataSetChanged alle Fragemnts refrehsed werden

    Log.d(logTAG, object.getClass().getName());
    return POSITION_NONE;
}

public Fragment getFragment(int position) {
    return getItem(position);
}

public String getTag(int position, int viewPagerId) {
    //getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.shares_detail_activity_viewpager + ":" + myViewPager.getCurrentItem())

    return "android:switcher:" + viewPagerId + ":" + position;
}

public MyPageBuilder getPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
    return new MyPageBuilder(pageTitle, icon, selectedIcon, frag);
}


public static class MyPageBuilder {

    private Fragment fragment;

    public Fragment getFragment() {
        return fragment;
    }

    public void setFragment(Fragment fragment) {
        this.fragment = fragment;
    }

    private String pageTitle;

    public String getPageTitle() {
        return pageTitle;
    }

    public void setPageTitle(String pageTitle) {
        this.pageTitle = pageTitle;
    }

    private int icon;

    public int getIconUnselected() {
        return icon;
    }

    public void setIconUnselected(int iconUnselected) {
        this.icon = iconUnselected;
    }

    private int iconSelected;

    public int getIconSelected() {
        return iconSelected;
    }

    public void setIconSelected(int iconSelected) {
        this.iconSelected = iconSelected;
    }

    public MyPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
        this.pageTitle = pageTitle;
        this.icon = icon;
        this.iconSelected = selectedIcon;
        this.fragment = frag;
    }
}

public static class MyPageArrayList extends ArrayList<MyPageBuilder> {
    private final String logTAG = MyPageArrayList.class.getName() + ".";

    public MyPageBuilder get(Class cls) {
        // Fragment über FragmentClass holen
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return super.get(indexOf(item));
            }
        }
        return null;
    }

    public String getTag(int viewPagerId, Class cls) {
        // Tag des Fragment unabhängig vom State z.B. nach bei Orientation change
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return "android:switcher:" + viewPagerId + ":" + indexOf(item);
            }
        }
        return null;
    }
}

तो बस टुकड़ों के साथ एक MyPageArrayList बनाएँ:

    myFragPages = new MyPageAdapter.MyPageArrayList();

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_data_frag),
            R.drawable.ic_sd_storage_24dp,
            R.drawable.ic_sd_storage_selected_24dp,
            new WidgetDataFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_color_frag),
            R.drawable.ic_color_24dp,
            R.drawable.ic_color_selected_24dp,
            new WidgetColorFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_textsize_frag),
            R.drawable.ic_settings_widget_24dp,
            R.drawable.ic_settings_selected_24dp,
            new WidgetTextSizeFrag()));

और उन्हें दृश्य में जोड़ें पेजर:

    mAdapter = new MyPageAdapter(getSupportFragmentManager(), myFragPages);
    myViewPager.setAdapter(mAdapter);

इसके बाद आप अभिविन्यास के बाद अपने वर्ग का उपयोग करके सही टुकड़ा बदल सकते हैं:

        WidgetDataFrag dataFragment = (WidgetDataFrag) getSupportFragmentManager()
            .findFragmentByTag(myFragPages.getTag(myViewPager.getId(), WidgetDataFrag.class));

जोड़ें:

   @SuppressLint("ValidFragment")

आपकी कक्षा से पहले।

यह काम नहीं करता है इस तरह कुछ करते हैं:

@SuppressLint({ "ValidFragment", "HandlerLeak" })

मुझे आपके प्रश्न के लिए एक और अपेक्षाकृत आसान समाधान मिला।

जैसा कि आप FragmentPagerAdapter स्रोत कोड से देख सकते हैं, FragmentPagerAdapter स्टोर द्वारा FragmentPagerAdapter प्रबंधित किए गए FragmentPagerAdapter का उपयोग करके उत्पन्न टैग के तहत:

String tag="android:switcher:" + viewId + ":" + index;

viewId container.getId() है viewId container.getId() , container आपका ViewPager उदाहरण है। index खंड की स्थिति है। इसलिए आप ऑब्जेक्ट आईडी को outState में outState :

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("viewpagerid" , mViewPager.getId() );
}

@Override
    protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);
    if (savedInstanceState != null)
        viewpagerid=savedInstanceState.getInt("viewpagerid", -1 );  

    MyFragmentPagerAdapter titleAdapter = new MyFragmentPagerAdapter (getSupportFragmentManager() , this);        
    mViewPager = (ViewPager) findViewById(R.id.pager);
    if (viewpagerid != -1 ){
        mViewPager.setId(viewpagerid);
    }else{
        viewpagerid=mViewPager.getId();
    }
    mViewPager.setAdapter(titleAdapter);

यदि आप इस खंड के साथ संवाद करना चाहते हैं, तो आप FragmentManager से प्राप्त कर सकते हैं, जैसे कि:

getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewpagerid + ":0")

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

यह एडाप्टर का कोड है (यहां कुछ भी अजीब नहीं है, इस तथ्य को छोड़कर कि mFragments गतिविधि द्वारा बनाए गए टुकड़ों की एक सूची है)

class MyFragmentPagerAdapter extends FragmentStatePagerAdapter {

    public MyFragmentPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return mFragments.get(position);
    }

    @Override
    public int getCount() {
        return mFragments.size();
    }

    @Override
    public int getItemPosition(Object object) {
        return POSITION_NONE;
    }

    @Override
    public CharSequence getPageTitle(int position) {
        TabFragment fragment = (TabFragment)mFragments.get(position);
        return fragment.getTitle();
    }
} 

इस धागे की पूरी समस्या "पुराने" टुकड़ों का संदर्भ प्राप्त कर रही है, इसलिए मैं इस कोड का उपयोग गतिविधि के ऑनक्रेट में करता हूं।

    if (savedInstanceState!=null) {
        if (getSupportFragmentManager().getFragments()!=null) {
            for (Fragment fragment : getSupportFragmentManager().getFragments()) {
                mFragments.add(fragment);
            }
        }
    }

बेशक यदि आप आवश्यक हो तो इस कोड को ट्यून कर सकते हैं, उदाहरण के लिए यह सुनिश्चित करना कि टुकड़े किसी विशेष वर्ग के उदाहरण हैं।

मैं एक समाधान प्रदान करना चाहता हूं जो antonyt के अद्भुत उत्तर और antonyt FragmentPageAdapter.instantiateItem(View, int) को ओवरराइड करने का उल्लेख करता है ताकि बनाए गए Fragments संदर्भों को सहेज सकें ताकि आप बाद में उन पर काम कर सकें। यह FragmentStatePagerAdapter साथ भी काम करना चाहिए; विवरण के लिए नोट्स देखें।

Fragments द्वारा लौटाए गए FragmentPagerAdapter संदर्भ कैसे प्राप्त करें इसका एक सरल उदाहरण यहां दिया गया है जो Fragments पर सेट किए गए आंतरिक tags पर भरोसा नहीं करता है। कुंजी को instantiateItem() getItem() में getItem() करना है और getItem() में इसके बजाय संदर्भों को सहेजना है।

public class SomeActivity extends Activity {
    private FragmentA m1stFragment;
    private FragmentB m2ndFragment;

    // other code in your Activity...

    private class CustomPagerAdapter extends FragmentPagerAdapter {
        // other code in your custom FragmentPagerAdapter...

        public CustomPagerAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public Fragment getItem(int position) {
            // Do NOT try to save references to the Fragments in getItem(),
            // because getItem() is not always called. If the Fragment
            // was already created then it will be retrieved from the FragmentManger
            // and not here (i.e. getItem() won't be called again).
            switch (position) {
                case 0:
                    return new FragmentA();
                case 1:
                    return new FragmentB();
                default:
                    // This should never happen. Always account for each position above
                    return null;
            }
        }

        // Here we can finally safely save a reference to the created
        // Fragment, no matter where it came from (either getItem() or
        // FragmentManger). Simply save the returned Fragment from
        // super.instantiateItem() into an appropriate reference depending
        // on the ViewPager position.
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
            // save the appropriate reference depending on position
            switch (position) {
                case 0:
                    m1stFragment = (FragmentA) createdFragment;
                    break;
                case 1:
                    m2ndFragment = (FragmentB) createdFragment;
                    break;
            }
            return createdFragment;
        }
    }

    public void someMethod() {
        // do work on the referenced Fragments, but first check if they
        // even exist yet, otherwise you'll get an NPE.

        if (m1stFragment != null) {
            // m1stFragment.doWork();
        }

        if (m2ndFragment != null) {
            // m2ndFragment.doSomeWorkToo();
        }
    }
}

या यदि आप Fragments के वर्ग वर्ग चर / संदर्भों के बजाय tags साथ काम करना पसंद करते हैं तो आप FragmentPagerAdapter द्वारा tags को उसी तरीके से भी पकड़ सकते हैं: नोट: यह FragmentStatePagerAdapter लागू नहीं होता है क्योंकि यह बनाते समय tags सेट नहीं करता है इसके Fragments

@Override
public Object instantiateItem(ViewGroup container, int position) {
    Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
    // get the tags set by FragmentPagerAdapter
    switch (position) {
        case 0:
            String firstTag = createdFragment.getTag();
            break;
        case 1:
            String secondTag = createdFragment.getTag();
            break;
    }
    // ... save the tags somewhere so you can reference them later
    return createdFragment;
}

ध्यान दें कि यह विधि FragmentPagerAdapter द्वारा आंतरिक tag सेट की नकल करने पर भरोसा नहीं करती है और इसके बजाय उन्हें पुनर्प्राप्त करने के लिए उचित API का उपयोग करती है। इस तरह अगर tag SupportLibrary भविष्य के संस्करणों में tag बदल जाता है तो भी आप सुरक्षित रहेंगे।

यह न भूलें कि आपकी Activity के डिज़ाइन के आधार पर, जिन Fragments आप काम करने की कोशिश कर रहे हैं, वे अभी तक मौजूद नहीं हो सकते हैं या नहीं, इसलिए आपको अपने संदर्भों का उपयोग करने से पहले null जांच करके इसका खाता लेना होगा।

इसके अलावा, यदि आप FragmentStatePagerAdapter साथ काम कर रहे हैं, तो आप अपने Fragments लिए कठिन संदर्भ नहीं रखना चाहते हैं क्योंकि आपके पास उनमें से कई हो सकते हैं और कठिन संदर्भ अनावश्यक रूप से उन्हें स्मृति में रखेंगे। इसके बजाय मानक वाले की बजाय WeakReference चर में Fragment संदर्भों को सहेजें। इस कदर:

WeakReference<Fragment> m1stFragment = new WeakReference<Fragment>(createdFragment);
// ...and access them like so
Fragment firstFragment = m1stFragment.get();
if (firstFragment != null) {
    // reference hasn't been cleared yet; do work...
}

BasePagerAdapter क्या है? आपको मानक पेजर एडेप्टरों में से एक का उपयोग करना चाहिए - या तो FragmentPagerAdapter या FragmentStatePagerAdapter , चाहे आप चाहते हैं कि Fragments जिन्हें अब ViewPager द्वारा (या पूर्व) को रखने के लिए आवश्यक नहीं है या उनके राज्य को सहेजा गया है (बाद वाला) और फिर यदि आवश्यक हो तो आवश्यक।

ViewPager का उपयोग करने के लिए नमूना कोड here पाया जा सकता here

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