ভিউপ্যাজারের ভিতরে টুকরা প্রতিস্থাপন করুন


268

আমি একটি ViewPagerব্যবহার করে ফ্র্যাগমেন্ট ব্যবহার করার চেষ্টা করছি FragmentPagerAdapter। আমি যেটি অর্জন করতে চাইছি তা হ'ল একটি খণ্ডকে প্রতিস্থাপন করা, এর প্রথম পৃষ্ঠায় অবস্থিত ViewPager, অন্য একটি দিয়ে।

পেজার দুটি পৃষ্ঠার সমন্বয়ে গঠিত। প্রথমটি হ'ল FirstPagerFragment, দ্বিতীয়টি হ'ল SecondPagerFragment। প্রথম পৃষ্ঠার একটি বোতামে ক্লিক করা। আমি FirstPagerFragmentনেক্সটফ্রেগমেন্টের সাথে প্রতিস্থাপন করতে চাই ।

নীচে আমার কোড আছে।

public class FragmentPagerActivity extends FragmentActivity {

    static final int NUM_ITEMS = 2;

    MyAdapter mAdapter;
    ViewPager mPager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_pager);

        mAdapter = new MyAdapter(getSupportFragmentManager());

        mPager = (ViewPager) findViewById(R.id.pager);
        mPager.setAdapter(mAdapter);

    }


    /**
     * Pager Adapter
     */
    public static class MyAdapter extends FragmentPagerAdapter {
        public MyAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public int getCount() {
            return NUM_ITEMS;
        }

        @Override
        public Fragment getItem(int position) {

            if(position == 0) {
                return FirstPageFragment.newInstance();
            } else {
                return SecondPageFragment.newInstance();
            }

        }
    }


    /**
     * Second Page FRAGMENT
     */
    public static class SecondPageFragment extends Fragment {

        public static SecondPageFragment newInstance() {
            SecondPageFragment f = new SecondPageFragment();
            return f;
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            //Log.d("DEBUG", "onCreateView");
            return inflater.inflate(R.layout.second, container, false);

        }
    }

    /**
     * FIRST PAGE FRAGMENT
     */
    public static class FirstPageFragment extends Fragment {

        Button button;

        public static FirstPageFragment newInstance() {
            FirstPageFragment f = new FirstPageFragment();
            return f;
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            //Log.d("DEBUG", "onCreateView");
            View root = inflater.inflate(R.layout.first, container, false);
            button = (Button) root.findViewById(R.id.button);
            button.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    FragmentTransaction trans = getFragmentManager().beginTransaction();
                                    trans.replace(R.id.first_fragment_root_id, NextFragment.newInstance());
                    trans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
                    trans.addToBackStack(null);
                    trans.commit();

                }

            });

            return root;
        }

        /**
     * Next Page FRAGMENT in the First Page
     */
    public static class NextFragment extends Fragment {

        public static NextFragment newInstance() {
            NextFragment f = new NextFragment();
            return f;
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            //Log.d("DEBUG", "onCreateView");
            return inflater.inflate(R.layout.next, container, false);

        }
    }
}

... এবং এখানে এক্সএমএল ফাইল রয়েছে

fragment_pager.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical" android:padding="4dip"
        android:gravity="center_horizontal"
        android:layout_width="match_parent" android:layout_height="match_parent">

    <android.support.v4.view.ViewPager
            android:id="@+id/pager"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1">
    </android.support.v4.view.ViewPager>

</LinearLayout>

first.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:id="@+id/first_fragment_root_id"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">

  <Button android:id="@+id/button"
     android:layout_width="wrap_content" android:layout_height="wrap_content"
     android:text="to next"/>

</LinearLayout>

এখন সমস্যা ... আমার কোন আইডি ব্যবহার করা উচিত?

trans.replace(R.id.first_fragment_root_id, NextFragment.newInstance());

?

যদি আমি ব্যবহার করি R.id.first_fragment_root_idতবে প্রতিস্থাপনটি কাজ করে তবে হাইয়ারাকির ভিউয়ার নীচের মত একটি অদ্ভুত আচরণ দেখায়।

শুরুতেই অবস্থাটা এমন

প্রতিস্থাপনের পরে পরিস্থিতি হচ্ছে

আপনি দেখতে পাচ্ছেন যে এখানে কিছু ভুল আছে, আমি টুকরোটি প্রতিস্থাপনের পরে প্রথম চিত্রের মতো দেখানো একই অবস্থাটি আশা করব।


আপনি কি কোনওভাবে সেই বিন্যাস চিত্রটি তৈরি করেছেন বা আপনি নিজে নিজে করেছিলেন?
জেরোইন ভেনেভিল

@ নুডলস: আমারও তাই করা দরকার। আপনার প্রশ্নটি বিভিন্ন বিভিন্ন উত্তর সহ একটি দীর্ঘ থ্রেড উত্পন্ন করেছে। শেষ পর্যন্ত সবচেয়ে ভাল কাজ কি? অনেক ধন্যবাদ!
নারব

1
@ জিরোওনভেনভেল আপনি এটি ইতিমধ্যে বুঝতে পেরেছেন, তবে সেই লেআউটটি চিত্রটি বিকাশকারী
অঙ্কিত পপলি

কিছু সমস্যা পেয়েছে আপনার সহায়তার দরকার stackoverflow.com/questions/40149039/…
অ্যালবার্ট

উত্তর:


162

অন্য সমাধান যে পরিবর্তন সোর্স কোড প্রয়োজন নেই ViewPagerএবং FragmentStatePagerAdapter, এবং এটি সঙ্গে কাজ করে FragmentPagerAdapterবেস লেখক দ্বারা ব্যবহৃত বর্গ।

আমি কোন আইডি ব্যবহার করব সে সম্পর্কে লেখকের প্রশ্নের উত্তর দিয়ে শুরু করতে চাই; এটি ধারকটির আইডি, অর্থাত প্যাজারের নিজেই আইডি। তবে, আপনি সম্ভবত নিজেরাই লক্ষ্য করেছেন যে, আপনার কোডটিতে এই আইডি ব্যবহার করার ফলে কিছুই ঘটতে পারে না। আমি ব্যাখ্যা করব কেন:

প্রথমত, ViewPagerপৃষ্ঠাগুলি পুনরায় সাজানোর জন্য আপনাকে কল করতে হবে notifyDataSetChanged()যা আপনার অ্যাডাপ্টারের বেস ক্লাসে থাকে।

দ্বিতীয়ত, কোন পৃষ্ঠাগুলি ধ্বংস করা উচিত এবং কোনটি রাখা উচিত তা পরীক্ষা করতে বিমূর্ত পদ্ধতিটি ViewPagerব্যবহার করে getItemPosition()। এই ফাংশনটির ডিফল্ট বাস্তবায়ন সর্বদা ফিরে আসে POSITION_UNCHANGED, যার ফলে ViewPagerসমস্ত বর্তমান পৃষ্ঠাগুলি রাখে এবং ফলস্বরূপ আপনার নতুন পৃষ্ঠা সংযুক্ত না হয়। সুতরাং, খণ্ড প্রতিস্থাপনের কাজটি করার জন্য getItemPosition()আপনার অ্যাডাপ্টারে ওভাররাইড করা দরকার এবং POSITION_NONEকোনও পুরানো সাথে ডাকলে, লুকিয়ে রাখতে, খণ্ড খণ্ড খণ্ড খণ্ডিত হিসাবে ফিরে আসতে হবে।

এর অর্থ হ'ল আপনার অ্যাডাপ্টারে সর্বদা সচেতন হওয়া প্রয়োজন যে কোন টুকরোটি 0-এ অবস্থানের মধ্যে প্রদর্শিত হবে FirstPageFragmentবা NextFragment। এটি করার একটি উপায় হ'ল তৈরি করার সময় শ্রোতাকে সরবরাহ করা FirstPageFragment, যা খণ্ডগুলিকে স্যুইচ করার সময় যখন ডাকা হবে। আমি মনে করি এটা একটা ভাল জিনিস যদিও, আপনার টুকরা অ্যাডাপ্টার হ্যান্ডেল যাক সব টুকরা সুইচ এবং কল হয় ViewPagerএবং FragmentManager

তৃতীয়ত, FragmentPagerAdapterব্যবহৃত নামগুলি একটি নাম দ্বারা ক্যাশে করে যা অবস্থান থেকে উদ্ভূত হয়, সুতরাং যদি 0 নম্বর পর্বে কোনও খণ্ড থাকে, তবে শ্রেণিটি নতুন হলেও এটি প্রতিস্থাপন করা হবে না। দুটি সমাধান রয়েছে, তবে সবচেয়ে সহজ হ'ল এর remove()ফাংশনটি ব্যবহার করা FragmentTransactionযা এটি এর ট্যাগটিকেও সরিয়ে ফেলবে।

এটি অনেক পাঠ্য ছিল, এখানে এমন কোড রয়েছে যা আপনার ক্ষেত্রে কাজ করা উচিত:

public class MyAdapter extends FragmentPagerAdapter
{
    static final int NUM_ITEMS = 2;
    private final FragmentManager mFragmentManager;
    private Fragment mFragmentAtPos0;

    public MyAdapter(FragmentManager fm)
    {
        super(fm);
        mFragmentManager = fm;
    }

    @Override
    public Fragment getItem(int position)
    {
        if (position == 0)
        {
            if (mFragmentAtPos0 == null)
            {
                mFragmentAtPos0 = FirstPageFragment.newInstance(new FirstPageFragmentListener()
                {
                    public void onSwitchToNextFragment()
                    {
                        mFragmentManager.beginTransaction().remove(mFragmentAtPos0).commit();
                        mFragmentAtPos0 = NextFragment.newInstance();
                        notifyDataSetChanged();
                    }
                });
            }
            return mFragmentAtPos0;
        }
        else
            return SecondPageFragment.newInstance();
    }

    @Override
    public int getCount()
    {
        return NUM_ITEMS;
    }

    @Override
    public int getItemPosition(Object object)
    {
        if (object instanceof FirstPageFragment && mFragmentAtPos0 instanceof NextFragment)
            return POSITION_NONE;
        return POSITION_UNCHANGED;
    }
}

public interface FirstPageFragmentListener
{
    void onSwitchToNextFragment();
}

আশা করি এটি যে কাউকে সাহায্য করবে!


24
আমার জন্যও কাজ করে, তবে প্রথম টুকরাটি দেখানোর জন্য কীভাবে ব্যাক বোতাম প্রয়োগ করা যায়?
ব্যবহারকারী 1159819

6
দুর্দান্ত ব্যাখ্যা কিন্তু আপনি কি এর পুরো উত্স কোডটি বিশেষত ফার্স্টপেজফ্রেগমেন্ট এবং সেকেন্ডপেজফ্র্যাগমেন্ট ক্লাস পোস্ট করতে পারেন।
জর্জিসিসি

6
কীভাবে আপনি নতুনআইন্সটেন্স () এ বান্ডেলটিতে ফার্স্টপেজফ্রেগমেন্টলিস্টনার যুক্ত করবেন?
মাইগুয়েল

4
আপনি FirstPageFragment.newInstance()শ্রোতাদের পরম দিয়ে পরিচালনা করেন এমন কোডটি কি আপনি যুক্ত করতে পারেন ?
মিগুয়েলহিনাপিসি

6
এটি কেবলমাত্র তখনই কাজ করে যদি আমি খণ্ডটি অপসারণ করার সময় কমিট () পরিবর্তে কমিটনউ () কে কল করি। আমার ব্যবহারের কেস আলাদা কেন তা নিশ্চিত নন তবে আশা করি এটি কারও কিছু সময় সাশ্রয় করবে।
ইয়ান লাভজয়

37

13 ই নভেম্বর, 2012 পর্যন্ত, ভিউপ্যাজারে টুকরো টুকরো টুকরো করা খুব সহজ হয়ে গেছে বলে মনে হচ্ছে। গুগল নেস্টেড টুকরোগুলি সমর্থন করে অ্যান্ড্রয়েড ৪.২ প্রকাশ করেছে এবং এটি নতুন অ্যান্ড্রয়েড সাপোর্ট লাইব্রেরি v11 এ সমর্থিত তাই এটি পুরোপুরি 1.6 এ কাজ করবে

আপনি getChildFraamentManager ব্যবহার না করে কোনও খণ্ডকে প্রতিস্থাপনের স্বাভাবিক পদ্ধতির সাথে খুব সমান। মনে হয় নেস্টেড টুকরা ব্যাকস্ট্যাকটি পপড করা ছাড়া কাজ করবে যখন ব্যবহারকারী পিছনের বোতামটি ক্লিক করবে। সেই লিঙ্কযুক্ত প্রশ্নের সমাধান অনুসারে আপনাকে খণ্ডের শিশু পরিচালকের কাছে ম্যানুয়ালি পপব্যাকস্ট্যাকমিডিয়েট () কল করতে হবে। সুতরাং আপনাকে ভিউপেজার ক্রিয়াকলাপের অনব্যাকপ্রেসড () টি ওভাররাইড করতে হবে যেখানে আপনি ভিউপ্যাজারের বর্তমান খণ্ডটি পাবেন এবং এটিতে চিটফ্রেগমেন্টম্যানেজার () পপব্যাকস্ট্যাকমিডিয়েট () কল করুন।

বর্তমানে প্রদর্শিত খণ্ডটি পাওয়া কিছুটা হ্যাকিও হ'ল, আমি এই নোংরা "অ্যান্ড্রয়েড: স্যুইচার: VIEWPAGER_ID: INDEX" সমাধানটি ব্যবহার করেছি তবে এই পৃষ্ঠার দ্বিতীয় সমাধানটিতে ব্যাখ্যা হিসাবে আপনি নিজের ভিউপ্যাজারের সমস্ত খণ্ডকেও নিজের নজর রাখতে পারেন ।

সুতরাং ব্যবহারকারী যখন একটি সারি ক্লিক করে এবং পিছনের বোতামটি কাজ করে তখন 4 পাতায় ভিউপিজারে প্রদর্শিত বিশদ দর্শনযুক্ত ভিউপ্যাজারের জন্য আমার কোডটি এখানে রয়েছে। আমি ব্রেভিটির জন্য কেবলমাত্র প্রাসঙ্গিক কোড অন্তর্ভুক্ত করার চেষ্টা করেছি তাই আপনি যদি গিটহাবের উপর পূর্ণ অ্যাপ্লিকেশন আপলোড করতে চান তবে একটি মন্তব্য দিন।

HomeActivity.java

 public class HomeActivity extends SherlockFragmentActivity {
FragmentAdapter mAdapter;
ViewPager mPager;
TabPageIndicator mIndicator;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    mAdapter = new FragmentAdapter(getSupportFragmentManager());
    mPager = (ViewPager)findViewById(R.id.pager);
    mPager.setAdapter(mAdapter);
    mIndicator = (TabPageIndicator)findViewById(R.id.indicator);
    mIndicator.setViewPager(mPager);
}

// This the important bit to make sure the back button works when you're nesting fragments. Very hacky, all it takes is some Google engineer to change that ViewPager view tag to break this in a future Android update.
@Override
public void onBackPressed() {
    Fragment fragment = (Fragment) getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.pager + ":"+mPager.getCurrentItem());
    if (fragment != null) // could be null if not instantiated yet
    {
        if (fragment.getView() != null) {
            // Pop the backstack on the ChildManager if there is any. If not, close this activity as normal.
            if (!fragment.getChildFragmentManager().popBackStackImmediate()) {
                finish();
            }
        }
    }
}

class FragmentAdapter extends FragmentPagerAdapter {        
    public FragmentAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        switch (position) {
        case 0:
            return ListProductsFragment.newInstance();
        case 1:
            return ListActiveSubstancesFragment.newInstance();
        case 2:
            return ListProductFunctionsFragment.newInstance();
        case 3:
            return ListCropsFragment.newInstance();
        default:
            return null;
        }
    }

    @Override
    public int getCount() {
        return 4;
    }

 }
}

ListProductsFragment.java

public class ListProductsFragment extends SherlockFragment {
private ListView list;

public static ListProductsFragment newInstance() {
    ListProductsFragment f = new ListProductsFragment();
    return f;
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View V = inflater.inflate(R.layout.list, container, false);
    list = (ListView)V.findViewById(android.R.id.list);
    list.setOnItemClickListener(new OnItemClickListener() {
        public void onItemClick(AdapterView<?> parent, View view,
            int position, long id) {
          // This is important bit
          Fragment productDetailFragment = FragmentProductDetail.newInstance();
          FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
          transaction.addToBackStack(null);
          transaction.replace(R.id.products_list_linear, productDetailFragment).commit();
        }
      });       
    return V;
}
}

7
গিথুবে আপনার কোড আপলোড করা কি সম্ভব হবে? ধন্যবাদ।
গৌতম

4
@ জর্জিসিসি: আমি এপিআই 17 ডাউনলোড করেছি, অ্যান্ড্রয়েড 4.2 যা আমাকে চিটফ্রেগমেন্টম্যানেজার () ব্যবহার করতে শুরু করেছে। তবে আমি অবশ্যই আপনার সমাধান থেকে কিছু হারিয়ে যাব, কারণ আমি এখন পর্দায় পুরানো + নতুন টুকরো টুকরো টুকরো টুকরো টুকরো করে ফেলছি। দ্রষ্টব্য: আমি আপনার সমাধানটি বিকাশকারী.অ্যান্ড্রয়েড . com/references/android/support/v4/view/… থেকে গুগলের উদাহরণ ট্যাবস অ্যাডাপ্টার কোডের সাথে কনসার্টে ব্যবহার করার চেষ্টা করছি । কোনও পরামর্শ এবং / অথবা রেফারেন্স কোডের জন্য ধন্যবাদ।
gcl1

27
আর.আইডি.প্রডাক্ট_লিস্ট_লাইনার কী বোঝায়? প্রস্তাবিত হিসাবে আপনার কোড লিঙ্ক করুন।
হোয়েটল

1
@ howettl বাইরের খণ্ডের সদস্যের আইডি উল্লেখ করে। এই সমস্যাটি সমাধানের মূল বিষয় হ'ল নেস্টেড টুকরা ব্যবহার করা (সেই উপায়ে আপনাকে ভিউপেজার অ্যাডাপ্টারটি ম্যানিপুলেট করতে হবে না)।
ইন্দ্রেক কোয়ে

2
এটি কি কখনও গিথুবে পরিণত হয়েছে?
বারুচ

32

@ উইজেজের উত্তরের ভিত্তিতে, যা আমি সহায়ক এবং মার্জিত বলে মনে করেছি, আমি যা আংশিকভাবে চেয়েছিলাম তা অর্জন করতে পেরেছিলাম, কারণ আমি চাইছিলাম যে ক্ষমতাটি একবার প্রতিস্থাপনের পরে প্রথম ফ্রেমে ফিরে যেতে পারে। আমি তার কোডটি কিছুটা সংশোধন করে তা অর্জন করেছি।

এটি ফ্রেগমেন্ট পেজারএডাপ্টার হবে:

public static class MyAdapter extends FragmentPagerAdapter {
    private final class CalendarPageListener implements
            CalendarPageFragmentListener {
        public void onSwitchToNextFragment() {
            mFragmentManager.beginTransaction().remove(mFragmentAtPos0)
                    .commit();
            if (mFragmentAtPos0 instanceof FirstFragment){
                mFragmentAtPos0 = NextFragment.newInstance(listener);
            }else{ // Instance of NextFragment
                mFragmentAtPos0 = FirstFragment.newInstance(listener);
            }
            notifyDataSetChanged();
        }
    }

    CalendarPageListener listener = new CalendarPageListener();;
    private Fragment mFragmentAtPos0;
    private FragmentManager mFragmentManager;

    public MyAdapter(FragmentManager fm) {
        super(fm);
        mFragmentManager = fm;
    }

    @Override
    public int getCount() {
        return NUM_ITEMS;
    }

    @Override
    public int getItemPosition(Object object) {
        if (object instanceof FirstFragment && mFragmentAtPos0 instanceof NextFragment)
            return POSITION_NONE;
        if (object instanceof NextFragment && mFragmentAtPos0 instanceof FirstFragment)
            return POSITION_NONE;
        return POSITION_UNCHANGED;
    }

    @Override
    public Fragment getItem(int position) {
        if (position == 0)
            return Portada.newInstance();
        if (position == 1) { // Position where you want to replace fragments
            if (mFragmentAtPos0 == null) {
                mFragmentAtPos0 = FirstFragment.newInstance(listener);
            }
            return mFragmentAtPos0;
        }
        if (position == 2)
            return Clasificacion.newInstance();
        if (position == 3)
            return Informacion.newInstance();

        return null;
    }
}

public interface CalendarPageFragmentListener {
    void onSwitchToNextFragment();
}

প্রতিস্থাপনটিকে সুগন্ধি করতে, কেবল ধরণের স্ট্যাটিক ক্ষেত্রটি সংজ্ঞায়িত করুন CalendarPageFragmentListenerএবং newInstanceসংশ্লিষ্ট টুকরোগুলির পদ্ধতিগুলির মাধ্যমে সূচনা করুন FirstFragment.pageListener.onSwitchToNextFragment()বা NextFragment.pageListener.onSwitchToNextFragment()সংক্ষেপে কল করুন ic


প্রতিস্থাপনটি কীভাবে সম্পাদন করবেন? onSwitchToNext পদ্ধতি ওভাররাইড না করে শ্রোতাকে আরম্ভ করা সম্ভব নয়।
লেয়ান্ড্রোস

1
আপনি যদি ডিভাইসটি ঘোরান তবে আপনি এমফ্রেগমেন্টএটিপোস0 এ সংরক্ষিত রাজ্যটি হারাবেন না?

@ সেব, ক্রিয়াকলাপের স্থিতি mFragmentAtPos0সংরক্ষণের সময় রেফারেন্সটি সংরক্ষণ করার জন্য আমি এই সমাধানটি আসলে উন্নত করেছি । এটি সবচেয়ে মার্জিত সমাধান নয়, তবে কাজ করে।
mdelolmo

আপনি আমার উত্তর দেখতে পারেন । এটি খণ্ডগুলি প্রতিস্থাপন করে এবং প্রথমটিতে ফিরে আসে।
লাইড

@ এমডেললমো আপনি ভিউপ্যাজার সম্পর্কে এই প্রশ্নটি একবার দেখে নিতে পারেন? আপনাকে স্ট্যাকওভারফ্লো.com
হোয়া ভু

21

আমি এর জন্য একটি সমাধান কার্যকর করেছি:

  • ট্যাবের অভ্যন্তরে গতিশীল খণ্ড প্রতিস্থাপন
  • প্রতি ট্যাব ইতিহাস রক্ষণাবেক্ষণ
  • ওরিয়েন্টেশন পরিবর্তনের সাথে কাজ করা

এটি অর্জনের কৌশলগুলি নিম্নলিখিত:

  • টুকরা প্রতিস্থাপন প্রয়োগ করতে notifyDataSetChanged () পদ্ধতিটি ব্যবহার করুন
  • টুকরা প্রতিস্থাপনের জন্য কেবল টুকরো টুকরো ব্যবস্থাপক ব্যবহার করুন stage
  • স্মৃতিসৌধের প্যাটার্ন (স্ট্যাক) ব্যবহার করে ইতিহাস বজায় রাখুন

অ্যাডাপ্টার কোডটি নিম্নলিখিত:

public class TabsAdapter extends FragmentStatePagerAdapter implements ActionBar.TabListener, ViewPager.OnPageChangeListener {

/** The sherlock fragment activity. */
private final SherlockFragmentActivity mActivity;

/** The action bar. */
private final ActionBar mActionBar;

/** The pager. */
private final ViewPager mPager;

/** The tabs. */
private List<TabInfo> mTabs = new LinkedList<TabInfo>();

/** The total number of tabs. */
private int TOTAL_TABS;

private Map<Integer, Stack<TabInfo>> history = new HashMap<Integer, Stack<TabInfo>>();

/**
 * Creates a new instance.
 *
 * @param activity the activity
 * @param pager    the pager
 */
public TabsAdapter(SherlockFragmentActivity activity, ViewPager pager) {
    super(activity.getSupportFragmentManager());
    activity.getSupportFragmentManager();
    this.mActivity = activity;
    this.mActionBar = activity.getSupportActionBar();
    this.mPager = pager;
    mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
}

/**
 * Adds the tab.
 *
 * @param image         the image
 * @param fragmentClass the class
 * @param args          the arguments
 */
public void addTab(final Drawable image, final Class fragmentClass, final Bundle args) {
    final TabInfo tabInfo = new TabInfo(fragmentClass, args);
    final ActionBar.Tab tab = mActionBar.newTab();
    tab.setTabListener(this);
    tab.setTag(tabInfo);
    tab.setIcon(image);

    mTabs.add(tabInfo);
    mActionBar.addTab(tab);

    notifyDataSetChanged();
}

@Override
public Fragment getItem(final int position) {
    final TabInfo tabInfo = mTabs.get(position);
    return Fragment.instantiate(mActivity, tabInfo.fragmentClass.getName(), tabInfo.args);
}

@Override
public int getItemPosition(final Object object) {
    /* Get the current position. */
    int position = mActionBar.getSelectedTab().getPosition();

    /* The default value. */
    int pos = POSITION_NONE;
    if (history.get(position).isEmpty()) {
        return POSITION_NONE;
    }

    /* Checks if the object exists in current history. */
    for (Stack<TabInfo> stack : history.values()) {
        TabInfo c = stack.peek();
        if (c.fragmentClass.getName().equals(object.getClass().getName())) {
            pos = POSITION_UNCHANGED;
            break;
        }
    }
    return pos;
}

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

@Override
public void onPageScrollStateChanged(int arg0) {
}

@Override
public void onPageScrolled(int arg0, float arg1, int arg2) {
}

@Override
public void onPageSelected(int position) {
    mActionBar.setSelectedNavigationItem(position);
}

@Override
public void onTabSelected(final ActionBar.Tab tab, final FragmentTransaction ft) {
    TabInfo tabInfo = (TabInfo) tab.getTag();
    for (int i = 0; i < mTabs.size(); i++) {
        if (mTabs.get(i).equals(tabInfo)) {
            mPager.setCurrentItem(i);
        }
    }
}

@Override
public void onTabUnselected(ActionBar.Tab tab, FragmentTransaction ft) {
}

@Override
public void onTabReselected(ActionBar.Tab tab, FragmentTransaction ft) {
}

public void replace(final int position, final Class fragmentClass, final Bundle args) {
    /* Save the fragment to the history. */
    mActivity.getSupportFragmentManager().beginTransaction().addToBackStack(null).commit();

    /* Update the tabs. */
    updateTabs(new TabInfo(fragmentClass, args), position);

    /* Updates the history. */
    history.get(position).push(new TabInfo(mTabs.get(position).fragmentClass, mTabs.get(position).args));

    notifyDataSetChanged();
}

/**
 * Updates the tabs.
 *
 * @param tabInfo
 *          the new tab info
 * @param position
 *          the position
 */
private void updateTabs(final TabInfo tabInfo, final int position) {
    mTabs.remove(position);
    mTabs.add(position, tabInfo);
    mActionBar.getTabAt(position).setTag(tabInfo);
}

/**
 * Creates the history using the current state.
 */
public void createHistory() {
    int position = 0;
    TOTAL_TABS = mTabs.size();
    for (TabInfo mTab : mTabs) {
        if (history.get(position) == null) {
            history.put(position, new Stack<TabInfo>());
        }
        history.get(position).push(new TabInfo(mTab.fragmentClass, mTab.args));
        position++;
    }
}

/**
 * Called on back
 */
public void back() {
    int position = mActionBar.getSelectedTab().getPosition();
    if (!historyIsEmpty(position)) {
        /* In case there is not any other item in the history, then finalize the activity. */
        if (isLastItemInHistory(position)) {
            mActivity.finish();
        }
        final TabInfo currentTabInfo = getPrevious(position);
        mTabs.clear();
        for (int i = 0; i < TOTAL_TABS; i++) {
            if (i == position) {
                mTabs.add(new TabInfo(currentTabInfo.fragmentClass, currentTabInfo.args));
            } else {
                TabInfo otherTabInfo = history.get(i).peek();
                mTabs.add(new TabInfo(otherTabInfo.fragmentClass, otherTabInfo.args));
            }
        }
    }
    mActionBar.selectTab(mActionBar.getTabAt(position));
    notifyDataSetChanged();
}

/**
 * Returns if the history is empty.
 *
 * @param position
 *          the position
 * @return  the flag if empty
 */
private boolean historyIsEmpty(final int position) {
    return history == null || history.isEmpty() || history.get(position).isEmpty();
}

private boolean isLastItemInHistory(final int position) {
    return history.get(position).size() == 1;
}

/**
 * Returns the previous state by the position provided.
 *
 * @param position
 *          the position
 * @return  the tab info
 */
private TabInfo getPrevious(final int position) {
    TabInfo currentTabInfo = history.get(position).pop();
    if (!history.get(position).isEmpty()) {
        currentTabInfo = history.get(position).peek();
    }
    return currentTabInfo;
}

/** The tab info class */
private static class TabInfo {

    /** The fragment class. */
    public Class fragmentClass;

    /** The args.*/
    public Bundle args;

    /**
     * Creates a new instance.
     *
     * @param fragmentClass
     *          the fragment class
     * @param args
     *          the args
     */
    public TabInfo(Class fragmentClass, Bundle args) {
        this.fragmentClass = fragmentClass;
        this.args = args;
    }

    @Override
    public boolean equals(final Object o) {
        return this.fragmentClass.getName().equals(o.getClass().getName());
    }

    @Override
    public int hashCode() {
        return fragmentClass.getName() != null ? fragmentClass.getName().hashCode() : 0;
    }

    @Override
    public String toString() {
        return "TabInfo{" +
                "fragmentClass=" + fragmentClass +
                '}';
    }
}

প্রথমবার আপনি যখন সমস্ত ট্যাব যুক্ত করেন, প্রাথমিক ইতিহাস তৈরি করার জন্য আমাদের পদ্ধতিটি ক্রিয়েটহিস্টরি () কল করতে হবে

public void createHistory() {
    int position = 0;
    TOTAL_TABS = mTabs.size();
    for (TabInfo mTab : mTabs) {
        if (history.get(position) == null) {
            history.put(position, new Stack<TabInfo>());
        }
        history.get(position).push(new TabInfo(mTab.fragmentClass, mTab.args));
        position++;
    }
}

যতবারই আপনি কল করে কোনও নির্দিষ্ট ট্যাবে কোনও খণ্ড প্রতিস্থাপন করতে চান: প্রতিস্থাপন করুন (চূড়ান্ত অভ্যন্তরীণ অবস্থান, চূড়ান্ত শ্রেণির টুকরা ক্লাস, চূড়ান্ত বান্ডিল আরগস)

/* Save the fragment to the history. */
    mActivity.getSupportFragmentManager().beginTransaction().addToBackStack(null).commit();

    /* Update the tabs. */
    updateTabs(new TabInfo(fragmentClass, args), position);

    /* Updates the history. */
    history.get(position).push(new TabInfo(mTabs.get(position).fragmentClass, mTabs.get(position).args));

    notifyDataSetChanged();

পিছনে চাপলে আপনাকে ফিরে () পদ্ধতিটি কল করতে হবে:

public void back() {
    int position = mActionBar.getSelectedTab().getPosition();
    if (!historyIsEmpty(position)) {
        /* In case there is not any other item in the history, then finalize the activity. */
        if (isLastItemInHistory(position)) {
            mActivity.finish();
        }
        final TabInfo currentTabInfo = getPrevious(position);
        mTabs.clear();
        for (int i = 0; i < TOTAL_TABS; i++) {
            if (i == position) {
                mTabs.add(new TabInfo(currentTabInfo.fragmentClass, currentTabInfo.args));
            } else {
                TabInfo otherTabInfo = history.get(i).peek();
                mTabs.add(new TabInfo(otherTabInfo.fragmentClass, otherTabInfo.args));
            }
        }
    }
    mActionBar.selectTab(mActionBar.getTabAt(position));
    notifyDataSetChanged();
}

সমাধানটি শার্লক অ্যাকশন বার এবং সোয়াইপ অঙ্গভঙ্গির সাথে কাজ করে।


এটা দুর্দান্ত! আপনি গিথুব উপর লাগাতে পারেন?
নিক্রামাস

এই বাস্তবায়নটি এখানে সরবরাহিত সকলের মধ্যে সবচেয়ে পরিষ্কার এবং প্রতিটি একক ইস্যুকে সম্বোধন করে। এটি গ্রহণযোগ্য উত্তর হওয়া উচিত।
dazedviper

কারও কি এই বাস্তবায়ন নিয়ে সমস্যা আছে? আমি তাদের 2 আছে। 1. প্রথম ফিরে নিবন্ধন করে না - এটি রেজিস্টার করার জন্য আমাকে আবার দুবার ক্লিক করতে হবে। ২. আমি ট্যাব এ-তে ফিরে (দুবার) ক্লিক করার পরে এবং আমি ট্যাব
বিতে

7

tl; dr: একটি হোস্ট টুকরা ব্যবহার করুন যা এর হোস্ট করা সামগ্রী প্রতিস্থাপনের জন্য দায়ী এবং পিছনে নেভিগেশন ইতিহাসের ট্র্যাক রাখে (ব্রাউজারের মতো)।

আপনার ব্যবহারের ক্ষেত্রে যেমন স্থির পরিমাণে ট্যাব থাকে তবে আমার সমাধানটি ভালভাবে কাজ করে: ধারণাটি ভিউপাগারকে একটি কাস্টম শ্রেণীর উদাহরণ দিয়ে পূরণ করা হবে HostFragment, এটি তার হোস্ট করা সামগ্রী প্রতিস্থাপন করতে সক্ষম এবং এর নিজস্ব পিছনে নেভিগেশন ইতিহাস রাখে। হোস্ট করা খণ্ডটি প্রতিস্থাপন করতে আপনি পদ্ধতিতে একটি কল করুন hostfragment.replaceFragment():

public void replaceFragment(Fragment fragment, boolean addToBackstack) {
    if (addToBackstack) {
        getChildFragmentManager().beginTransaction().replace(R.id.hosted_fragment, fragment).addToBackStack(null).commit();
    } else {
        getChildFragmentManager().beginTransaction().replace(R.id.hosted_fragment, fragment).commit();
    }
}

সমস্ত যে পদ্ধতিটি করে তা হ'ল আইডির R.id.hosted_fragmentসাথে ফ্রেম বিন্যাসটি পদ্ধতিতে সরবরাহিত টুকরাটির সাথে প্রতিস্থাপন করা ।

আরও বিশদ এবং গিটহাবের একটি সম্পূর্ণ কার্যকারী উদাহরণের জন্য এই বিষয়ে আমার টিউটোরিয়ালটি দেখুন !


যদিও এটি clumsier দেখায়, আমি মনে করি বাস্তবে এটি করার সর্বোত্তম উপায় (কাঠামো এবং রক্ষণাবেক্ষণের স্বাচ্ছন্দ্যের দিক থেকে) way
সিরা লাম

আমি একটি এনপিই হেডবুট শেষ। : / যে প্রতিস্থাপনটি করা হবে তা খুঁজে পাচ্ছেন না
ফরিজ ফক্কেল

6

উপস্থাপিত কিছু সমাধান আমাকে সমস্যাটিকে আংশিকভাবে সমাধান করতে অনেক সহায়তা করেছে তবে সমাধানগুলিতে এখনও একটি গুরুত্বপূর্ণ বিষয় অনুপস্থিত যা কিছু ক্ষেত্রে খণ্ডিত সামগ্রীর পরিবর্তে অপ্রত্যাশিত ব্যতিক্রম এবং কালো পৃষ্ঠার সামগ্রী তৈরি করেছে।

জিনিসটি হ'ল ফ্রেগমেন্টপেইজারএডাপ্টার শ্রেণি আইটেম আইডি ব্যবহার করে ফ্রেমমেন্টম্যানেজারে ক্যাশেড টুকরো সংরক্ষণ করে । এই কারণে, আপনাকে getItemId (int পজিশন) পদ্ধতিটিও ওভাররাইড করতে হবে যাতে এটি শীর্ষ স্তরের পৃষ্ঠাগুলির জন্য যেমন অবস্থান এবং বিশদ পৃষ্ঠাগুলির জন্য 100 + অবস্থানের ফিরে আসে । অন্যথায় পূর্বে তৈরি শীর্ষ-স্তরের খণ্ডটি বিশদ-স্তরের খণ্ডের পরিবর্তে ক্যাশে থেকে ফিরে আসবে।

উপরন্তু, আমি এখানে সম্পূর্ণ দৃষ্টান্তমূলক বাস্তবায়ন সঙ্গে কার্যকলাপ ট্যাব মত ভাগ করছি অসম্পূর্ণ অংশ ব্যবহার পৃষ্ঠাগুলি ViewPager এবং ব্যবহার ট্যাব বোতাম RadioGroup যে বিস্তারিত পৃষ্ঠাগুলির সাথে টপ লেভেল পৃষ্ঠাগুলির প্রতিস্থাপন পারবেন এবং ব্যাক বোতাম সমর্থন করে। এই বাস্তবায়নটি কেবলমাত্র এক স্তরের ব্যাক স্ট্যাকিংকে সমর্থন করে (আইটেমের তালিকা - আইটেমের বিশদ) তবে মাল্টি-লেভেল ব্যাক স্ট্যাকিং বাস্তবায়ন সোজা। আপনি উদাহরণস্বরূপ দ্বিতীয় পৃষ্ঠায় স্যুইচ করলে, প্রথম পৃষ্ঠার খণ্ডটি পরিবর্তন করুন (যখন দৃশ্যমান নয়) এবং প্রথম পৃষ্ঠায় ফিরে আসার ক্ষেত্রে এই উদাহরণটি সাধারণ ক্ষেত্রে খুব ভালভাবে কাজ করে it আমি একবার এটিকে বের করার পরে এই সমস্যার সমাধান পোস্ট করব:

public class TabsActivity extends FragmentActivity {

  public static final int PAGE_COUNT = 3;
  public static final int FIRST_PAGE = 0;
  public static final int SECOND_PAGE = 1;
  public static final int THIRD_PAGE = 2;

  /**
   * Opens a new inferior page at specified tab position and adds the current page into back
   * stack.
   */
  public void startPage(int position, Fragment content) {
    // Replace page adapter fragment at position.
    mPagerAdapter.start(position, content);
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Initialize basic layout.
    this.setContentView(R.layout.tabs_activity);

    // Add tab fragments to view pager.
    {
      // Create fragments adapter.
      mPagerAdapter = new PagerAdapter(pager);
      ViewPager pager = (ViewPager) super.findViewById(R.id.tabs_view_pager);
      pager.setAdapter(mPagerAdapter);

      // Update active tab in tab bar when page changes.
      pager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
        @Override
        public void onPageScrolled(int index, float value, int nextIndex) {
          // Not used.
        }

        @Override
        public void onPageSelected(int index) {
          RadioGroup tabs_radio_group = (RadioGroup) TabsActivity.this.findViewById(
            R.id.tabs_radio_group);
          switch (index) {
            case 0: {
              tabs_radio_group.check(R.id.first_radio_button);
            }
            break;
            case 1: {
              tabs_radio_group.check(R.id.second_radio_button);
            }
            break;
            case 2: {
              tabs_radio_group.check(R.id.third_radio_button);
            }
            break;
          }
        }

        @Override
        public void onPageScrollStateChanged(int index) {
          // Not used.
        }
      });
    }

    // Set "tabs" radio group on checked change listener that changes the displayed page.
    RadioGroup radio_group = (RadioGroup) this.findViewById(R.id.tabs_radio_group);
    radio_group.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
      @Override
      public void onCheckedChanged(RadioGroup radioGroup, int id) {
        // Get view pager representing tabs.
        ViewPager view_pager = (ViewPager) TabsActivity.this.findViewById(R.id.tabs_view_pager);
        if (view_pager == null) {
          return;
        }

        // Change the active page.
        switch (id) {
          case R.id.first_radio_button: {
            view_pager.setCurrentItem(FIRST_PAGE);
          }
          break;
          case R.id.second_radio_button: {
            view_pager.setCurrentItem(SECOND_PAGE);
          }
          break;
          case R.id.third_radio_button: {
            view_pager.setCurrentItem(THIRD_PAGE);
          }
          break;
        }
      });
    }
  }

  @Override
  public void onBackPressed() {
    if (!mPagerAdapter.back()) {
      super.onBackPressed();
    }
  }

  /**
   * Serves the fragments when paging.
   */
  private class PagerAdapter extends FragmentPagerAdapter {

    public PagerAdapter(ViewPager container) {
      super(TabsActivity.this.getSupportFragmentManager());

      mContainer = container;
      mFragmentManager = TabsActivity.this.getSupportFragmentManager();

      // Prepare "empty" list of fragments.
      mFragments = new ArrayList<Fragment>(){};
      mBackFragments = new ArrayList<Fragment>(){};
      for (int i = 0; i < PAGE_COUNT; i++) {
        mFragments.add(null);
        mBackFragments.add(null);
      }
    }

    /**
     * Replaces the view pager fragment at specified position.
     */
    public void replace(int position, Fragment fragment) {
      // Get currently active fragment.
      Fragment old_fragment = mFragments.get(position);
      if (old_fragment == null) {
        return;
      }

      // Replace the fragment using transaction and in underlaying array list.
      // NOTE .addToBackStack(null) doesn't work
      this.startUpdate(mContainer);
      mFragmentManager.beginTransaction().setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN)
        .remove(old_fragment).add(mContainer.getId(), fragment)
        .commit();
      mFragments.set(position, fragment);
      this.notifyDataSetChanged();
      this.finishUpdate(mContainer);
    }

    /**
     * Replaces the fragment at specified position and stores the current fragment to back stack
     * so it can be restored by #back().
     */
    public void start(int position, Fragment fragment) {
      // Remember current fragment.
      mBackFragments.set(position, mFragments.get(position));

      // Replace the displayed fragment.
      this.replace(position, fragment);
    }

    /**
     * Replaces the current fragment by fragment stored in back stack. Does nothing and returns
     * false if no fragment is back-stacked.
     */
    public boolean back() {
      int position = mContainer.getCurrentItem();
      Fragment fragment = mBackFragments.get(position);
      if (fragment == null) {
        // Nothing to go back.
        return false;
      }

      // Restore the remembered fragment and remove it from back fragments.
      this.replace(position, fragment);
      mBackFragments.set(position, null);
      return true;
    }

    /**
     * Returns fragment of a page at specified position.
     */
    @Override
    public Fragment getItem(int position) {
      // If fragment not yet initialized, create its instance.
      if (mFragments.get(position) == null) {
        switch (position) {
          case FIRST_PAGE: {
            mFragments.set(FIRST_PAGE, new DefaultFirstFragment());
          }
          break;
          case SECOND_PAGE: {
            mFragments.set(SECOND_PAGE, new DefaultSecondFragment());
          }
          break;
          case THIRD_PAGE: {
            mFragments.set(THIRD_PAGE, new DefaultThirdFragment());
          }
          break;
        }
      }

      // Return fragment instance at requested position.
      return mFragments.get(position);
    }

    /**
     * Custom item ID resolution. Needed for proper page fragment caching.
     * @see FragmentPagerAdapter#getItemId(int).
     */
    @Override
    public long getItemId(int position) {
      // Fragments from second level page hierarchy have their ID raised above 100. This is
      // important to FragmentPagerAdapter because it is caching fragments to FragmentManager with
      // this item ID key.
      Fragment item = mFragments.get(position);
      if (item != null) {
        if ((item instanceof NewFirstFragment) || (item instanceof NewSecondFragment) ||
          (item instanceof NewThirdFragment)) {
          return 100 + position;
        }
      }

      return position;
    }

    /**
     * Returns number of pages.
     */
    @Override
    public int getCount() {
      return mFragments.size();
    }

    @Override
    public int getItemPosition(Object object)
    {
      int position = POSITION_UNCHANGED;
      if ((object instanceof DefaultFirstFragment) || (object instanceof NewFirstFragment)) {
        if (object.getClass() != mFragments.get(FIRST_PAGE).getClass()) {
          position = POSITION_NONE;
        }
      }
      if ((object instanceof DefaultSecondragment) || (object instanceof NewSecondFragment)) {
        if (object.getClass() != mFragments.get(SECOND_PAGE).getClass()) {
          position = POSITION_NONE;
        }
      }
      if ((object instanceof DefaultThirdFragment) || (object instanceof NewThirdFragment)) {
        if (object.getClass() != mFragments.get(THIRD_PAGE).getClass()) {
          position = POSITION_NONE;
        }
      }
      return position;
    }

    private ViewPager mContainer;
    private FragmentManager mFragmentManager;

    /**
     * List of page fragments.
     */
    private List<Fragment> mFragments;

    /**
     * List of page fragments to return to in onBack();
     */
    private List<Fragment> mBackFragments;
  }

  /**
   * Tab fragments adapter.
   */
  private PagerAdapter mPagerAdapter;
}

হুম, এই কোডটি সহ আরও একটি সমস্যা রয়েছে। আমি যখন খণ্ডের থেকে কোনও ক্রিয়াকলাপ শুরু করতে চাই যা মুছে ফেলা হয়েছে এবং যোগ করা হয়েছিল, তখন আমি একটি ত্রুটি পেয়েছি: "ব্যর্থতা সংরক্ষণের অবস্থা: সক্রিয় নিউফার্সফ্র্যাগমেন্ট {405478a0 index সূচকটি সাফ করেছে: -1" (সম্পূর্ণ স্ট্যাক ট্রেস: nopaste.info/547a23dfea.html )। অ্যান্ড্রয়েড উত্সগুলির দিকে তাকিয়ে, আমি বুঝতে পারি যে এটি ব্যাকস্ট্যাকের সাথে কিছু করার আছে তবে আমি এখনও এটিকে ঠিক করতে জানি না don't কারো কাছে কি কোন ধারণা আছে?
ব্ল্যাকহেক্স

2
শীতল, <code> mFraamentManager.beginTransaction () ব্যবহার করুন। আলাদা (পুরাতন_ফ্র্যাগমেন্ট) .ট্যাচ (খণ্ড) পুরাতন_প্রেগমেন্ট) .এডড (এমকন্টেইনার.জেটআইডি (), টুকরা) .কমিট (); </ translation> উপরের উদাহরণে উভয় সমস্যার সমাধান করা হবে বলে মনে হচ্ছে :-)।
ব্ল্যাকহেক্স

1
আপনি যদি এই পদ্ধতিটি ব্যবহার করেন তবে নিশ্চিত হয়ে নিন যে ডিভাইসটি ঘোরানোর সময় অ্যান্ড্রয়েডকে আপনার ক্রিয়াকলাপটি পুনরায় তৈরি করতে দিচ্ছেন না। অন্যথায়, পেজারআডাপ্টার পুনরায় তৈরি করা হবে এবং আপনি আপনার এমব্যাকফ্র্যামেন্টগুলি হারাবেন। এটি ফ্র্যাগমেন্টম্যানেজারকে মারাত্মকভাবে বিভ্রান্ত করবে। ব্যাকস্ট্যাকটি ব্যবহার করা এই সমস্যাটিকে এড়িয়ে চলে, পেজারআডাপ্টারের আরও জটিল বাস্তবায়নের ব্যয়ে (যেমন আপনি ফ্রেগমেন্টপেজার অ্যাডাপ্টারের উত্তরাধিকারী হতে পারবেন না
নর্মন

6

আমি সূচি 2 এবং 3 এর জন্য 3 টি উপাদান এবং 2 উপ উপাদান সহ একটি ভিউপেজার তৈরি করেছি এবং এখানে আমি কী করতে চাইছিলাম ..

এখানে চিত্র বর্ণনা লিখুন

আমি স্ট্যাকওভারফ্লো এর পূর্ববর্তী প্রশ্ন এবং উত্তরগুলির সাহায্যে এটি বাস্তবায়ন করেছি এবং এখানে লিঙ্কটি দেওয়া হয়েছে।

ViewPagerChildFragments


আপনার প্রকল্পটি ব্যর্থ হয়, যদি আপনি ডিভাইসটি ঘোরান।
ডুরি

6

একটি ভিতরে একটি টুকরা প্রতিস্থাপন করতে ViewPagerআপনি উৎস কোডের স্থানান্তর করতে পারেন ViewPager, PagerAdapterএবং FragmentStatePagerAdapterআপনার প্রকল্পে শ্রেণীর এবং কোড নিম্নলিখিত যোগ করুন।

মধ্যে ViewPager:

public void notifyItemChanged(Object oldItem, Object newItem) {
    if (mItems != null) {
            for (ItemInfo itemInfo : mItems) {
                        if (itemInfo.object.equals(oldItem)) {
                                itemInfo.object = newItem;
                        }
                    }
       }
       invalidate();
    }

ফ্র্যাগমেন্টস্টেটপেজারএডাপ্টারে:

public void replaceFragmetns(ViewPager container, Fragment oldFragment, Fragment newFragment) {
       startUpdate(container);

       // remove old fragment

       if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }
       int position = getFragmentPosition(oldFragment);
        while (mSavedState.size() <= position) {
            mSavedState.add(null);
        }
        mSavedState.set(position, null);
        mFragments.set(position, null);

        mCurTransaction.remove(oldFragment);

        // add new fragment

        while (mFragments.size() <= position) {
            mFragments.add(null);
        }
        mFragments.set(position, newFragment);
        mCurTransaction.add(container.getId(), newFragment);

       finishUpdate(container);

       // ensure getItem returns newFragemtn after calling handleGetItemInbalidated()
       handleGetItemInbalidated(container, oldFragment, newFragment);

       container.notifyItemChanged(oldFragment, newFragment);
    }

protected abstract void handleGetItemInbalidated(View container, Fragment oldFragment, Fragment newFragment);
protected abstract int  getFragmentPosition(Fragment fragment);

handleGetItemInvalidated()তা নিশ্চিত করে যে এর পরবর্তী কল করার পরে আপনার অ্যাডাপ্টারে খণ্ডের নতুন ফ্র্যাগমেন্টের অবস্থান getItem()ফিরে getFragmentPosition()আসে।

এখন, টুকরা কল প্রতিস্থাপন

mAdapter.replaceFragmetns(mViewPager, oldFragment, newFragment);

আপনি যদি উদাহরণস্বরূপ প্রকল্পে আগ্রহী হন তবে আমাকে উত্সের জন্য জিজ্ঞাসা করুন।


পদ্ধতিগুলি কীভাবে ফ্রেমগমেন্ট পজিশন () এবং হ্যান্ডেলগেটটাইমআইনবিলেটেড () হওয়া উচিত? আমি নিউফ্র্যাগমেন্টটি ফিরে পেতে getItem () আপডেট করতে অক্ষম .. দয়া করে সহায়তা করুন ..

ওহে! দয়া করে এই লিঙ্কে পরীক্ষার প্রকল্পটি ফাইলগুলি
AndroidTeam এ মেল.আর

1
আপনার পরীক্ষা প্রকল্পটি ব্যর্থ হয়, যদি আপনি ডিভাইসটি ঘোরান।

1
@ AndroidTeamAtMail.Ru লিঙ্কটি শেষ হয়ে গেছে বলে মনে হচ্ছে W আপনি দয়া করে কোডটি ভাগ করুন
সানি

আপনি আমার উত্তর দেখতে পারেন । এটি খণ্ডগুলি প্রতিস্থাপন করে এবং প্রথমটিতে ফিরে আসে।
লাইড

4

অ্যান্ড্রয়েডটিমের সমাধান সহ দুর্দান্ত কাজ করে, তবে আমি দেখতে পেয়েছি যে আমার অনেকটা পিছনে ফিরে যাওয়ার দক্ষতার প্রয়োজন ছিল FrgmentTransaction.addToBackStack(null) তবে কেবল এটি যুক্ত করা কেবলমাত্র ভিউপ্যাজারকে না জানিয়ে ফ্রেগমেন্টটি প্রতিস্থাপন করবে। এই সামান্য বর্ধনের সাথে সরবরাহিত সমাধানের সংমিশ্রণ আপনাকে কেবল ক্রিয়াকলাপের onBackPressed()পদ্ধতিটিকে ওভাররাইড করে আগের অবস্থায় ফিরে যেতে দেয় । সবচেয়ে বড় অসুবিধা হ'ল এটি একবারে একবারে ফিরে যাবে যার ফলস্বরূপ একাধিক ব্যাক ক্লিক হতে পারে

private ArrayList<Fragment> bFragments = new ArrayList<Fragment>();
private ArrayList<Integer> bPosition = new ArrayList<Integer>();

public void replaceFragmentsWithBackOut(ViewPager container, Fragment oldFragment, Fragment newFragment) {
    startUpdate(container);

    // remove old fragment

    if (mCurTransaction == null) {
         mCurTransaction = mFragmentManager.beginTransaction();
     }
    int position = getFragmentPosition(oldFragment);
     while (mSavedState.size() <= position) {
         mSavedState.add(null);
     }

     //Add Fragment to Back List
     bFragments.add(oldFragment);

     //Add Pager Position to Back List
     bPosition.add(position);

     mSavedState.set(position, null);
     mFragments.set(position, null);

     mCurTransaction.remove(oldFragment);

     // add new fragment

     while (mFragments.size() <= position) {
         mFragments.add(null);
     }
     mFragments.set(position, newFragment);
     mCurTransaction.add(container.getId(), newFragment);

    finishUpdate(container);

    // ensure getItem returns newFragemtn after calling handleGetItemInbalidated()
    handleGetItemInvalidated(container, oldFragment, newFragment);

    container.notifyItemChanged(oldFragment, newFragment);
 }


public boolean popBackImmediate(ViewPager container){
    int bFragSize = bFragments.size();
    int bPosSize = bPosition.size();

    if(bFragSize>0 && bPosSize>0){
        if(bFragSize==bPosSize){
            int last = bFragSize-1;
            int position = bPosition.get(last);

            //Returns Fragment Currently at this position
            Fragment replacedFragment = mFragments.get(position);               
            Fragment originalFragment = bFragments.get(last);

            this.replaceFragments(container, replacedFragment, originalFragment);

            bPosition.remove(last);
            bFragments.remove(last);

            return true;
        }
    }

    return false;       
}

আশা করি এটি কাউকে সাহায্য করবে।

এছাড়াও যতদূর getFragmentPosition()যায় এটি getItem()বিপরীতে বেশ কিছুটা । আপনি জানেন যে কোন টুকরোগুলি কোথায় গেছে, কেবলমাত্র এটি সঠিক অবস্থানে থাকবে তা নিশ্চিত করুন Here এখানে একটি উদাহরণ রয়েছে:

    @Override
    protected int getFragmentPosition(Fragment fragment) {
            if(fragment.equals(originalFragment1)){
                return 0;
            }
            if(fragment.equals(replacementFragment1)){
                return 0;
            }
            if(fragment.equals(Fragment2)){
                return 1;
            }
        return -1;
    }

3

আপনার onCreateViewপদ্ধতিতে containerআসলে একটি ViewPagerউদাহরণ।

সুতরাং, শুধু কলিং

ViewPager vpViewPager = (ViewPager) container;
vpViewPager.setCurrentItem(1);

আপনার বর্তমান খণ্ড পরিবর্তন করবে ViewPager


1
অনুসন্ধানের কয়েক ঘন্টা থেকে, কোডের এই এক লাইনের মধ্যে আমার সমস্ত ট্যাবগুলি সঠিকভাবে কাজ করা প্রয়োজন। vpViewPager.setCurrentItem(1);। আমি প্রতিটি ব্যক্তির উদাহরণ দিয়ে গেলাম, যতক্ষণ না শেষ পর্যন্ত আপনার কাছে পৌঁছেছি ততবার কিছুই ঘটেনি। ধন্যবাদ.
ব্র্যান্ডন 19

1
মন ফুঁকছে ... এটা আশ্চর্যজনক !! আমি বুঝতে পারিনি যে ধারক পরিবর্তনশীলটি নিজেই ভিউপ্যাজার। এই উত্তরটি অন্য সমস্ত দীর্ঘতর উত্তরগুলির আগে প্রথমে অনুসন্ধান করতে হবে। এছাড়াও, ফ্রেগমেন্ট কনস্ট্রাক্টরের শ্রোতার ভেরিয়েবলগুলির কোনও পাসিং নেই যা কনফিগারেশনের পরিবর্তনের সময় অ্যান্ড্রয়েড ডিফল্ট নো-আরগ কনস্ট্রাক্টর ব্যবহার করে টুকরো টুকরো টুকরো টুকরো করে পুনঃস্থাপন করে সমস্ত বাস্তবায়ন সহজতর করে।
কেভিন লি

3
এটি কি কেবল বিদ্যমান ট্যাবে পরিবর্তন হচ্ছে না? এটি টুকরা প্রতিস্থাপনের সাথে কীভাবে সম্পর্কিত?
বেহালিট

2
@ বিহেলিটের সাথে একমত হোন, এটি প্রশ্নের উত্তর দেয় না, এটি কেবল ViewPagerঅন্য পৃষ্ঠায় চলে যাবে, এটি কোনও খণ্ড প্রতিস্থাপন করবে না।
ইয়োন হারকিউট

2

এই সমস্যাটির জন্য আমার তুলনামূলক সহজ সমাধান এখানে। এই সমাধানের কীগুলি FragmentStatePagerAdapterপরিবর্তে FragmentPagerAdapterপ্রাক্তনগুলি আপনার অব্যবহৃত টুকরো অপসারণ করবে এবং পরবর্তীকালে এখনও তাদের দৃষ্টান্তগুলি বজায় রাখার পরিবর্তে ব্যবহার করা হবে। দ্বিতীয়টি হ'ল POSITION_NONEগেট আইটেম () ব্যবহার । আমি আমার টুকরো টুকরো রাখতে একটি সাধারণ তালিকা ব্যবহার করেছি। আমার প্রয়োজনটি ছিল টুকরোগুলির সম্পূর্ণ তালিকাটি একবারে একটি নতুন তালিকার সাথে প্রতিস্থাপন করা, তবে পৃথক টুকরো টুকরো প্রতিস্থাপনের জন্য নীচে সহজেই পরিবর্তন করা যেতে পারে:

public class MyFragmentAdapter extends FragmentStatePagerAdapter {
    private List<Fragment> fragmentList = new ArrayList<Fragment>();
    private List<String> tabTitleList = new ArrayList<String>();

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

    public void addFragments(List<Fragment> fragments, List<String> titles) {
        fragmentList.clear();
        tabTitleList.clear();
        fragmentList.addAll(fragments);
        tabTitleList.addAll(titles);
        notifyDataSetChanged();
    }

    @Override
    public int getItemPosition(Object object) {
        if (fragmentList.contains(object)) {
            return POSITION_UNCHANGED;
        }
        return POSITION_NONE;
    }

    @Override
    public Fragment getItem(int item) {
        if (item >= fragmentList.size()) {
            return null;
        }
        return fragmentList.get(item);
    }

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

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

2

আমি একটি সমাধানও তৈরি করেছি, যা স্ট্যাকসের সাথে কাজ করছে । এটি একটি আরও মডুলার পদ্ধতির যাতে আপনার নিজের প্রতিটি খণ্ড এবং বিশদ বিবরণ নির্দিষ্ট করতে হবে না FragmentPagerAdapter। এটি অ্যাকশনবারেরলক থেকে প্রাপ্ত উদাহরণের শীর্ষে রয়েছে যা আমি ঠিক গুগল ডেমো অ্যাপ থেকে আছি যদি উত্পন্ন হয়।

/**
 * This is a helper class that implements the management of tabs and all
 * details of connecting a ViewPager with associated TabHost.  It relies on a
 * trick.  Normally a tab host has a simple API for supplying a View or
 * Intent that each tab will show.  This is not sufficient for switching
 * between pages.  So instead we make the content part of the tab host
 * 0dp high (it is not shown) and the TabsAdapter supplies its own dummy
 * view to show as the tab content.  It listens to changes in tabs, and takes
 * care of switch to the correct paged in the ViewPager whenever the selected
 * tab changes.
 * 
 * Changed to support more Layers of fragments on each Tab.
 * by sebnapi (2012)
 * 
 */
public class TabsAdapter extends FragmentPagerAdapter
        implements TabHost.OnTabChangeListener, ViewPager.OnPageChangeListener {
    private final Context mContext;
    private final TabHost mTabHost;
    private final ViewPager mViewPager;

    private ArrayList<String> mTabTags = new ArrayList<String>();
    private HashMap<String, Stack<TabInfo>> mTabStackMap = new HashMap<String, Stack<TabInfo>>();

    static final class TabInfo {
        public final String tag;
        public final Class<?> clss;
        public Bundle args;

        TabInfo(String _tag, Class<?> _class, Bundle _args) {
            tag = _tag;
            clss = _class;
            args = _args;
        }
    }

    static class DummyTabFactory implements TabHost.TabContentFactory {
        private final Context mContext;

        public DummyTabFactory(Context context) {
            mContext = context;
        }

        @Override
        public View createTabContent(String tag) {
            View v = new View(mContext);
            v.setMinimumWidth(0);
            v.setMinimumHeight(0);
            return v;
        }
    }

    public interface SaveStateBundle{
        public Bundle onRemoveFragment(Bundle outState);
    }

    public TabsAdapter(FragmentActivity activity, TabHost tabHost, ViewPager pager) {
        super(activity.getSupportFragmentManager());
        mContext = activity;
        mTabHost = tabHost;
        mViewPager = pager;
        mTabHost.setOnTabChangedListener(this);
        mViewPager.setAdapter(this);
        mViewPager.setOnPageChangeListener(this);
    }

    /**
     * Add a Tab which will have Fragment Stack. Add Fragments on this Stack by using
     * addFragment(FragmentManager fm, String _tag, Class<?> _class, Bundle _args)
     * The Stack will hold always the default Fragment u add here.
     * 
     * DON'T ADD Tabs with same tag, it's not beeing checked and results in unexpected
     * beahvior.
     * 
     * @param tabSpec
     * @param clss
     * @param args
     */
    public void addTab(TabHost.TabSpec tabSpec, Class<?> clss, Bundle args){
        Stack<TabInfo> tabStack = new Stack<TabInfo>();

        tabSpec.setContent(new DummyTabFactory(mContext));
        mTabHost.addTab(tabSpec);
        String tag = tabSpec.getTag();
        TabInfo info = new TabInfo(tag, clss, args);

        mTabTags.add(tag);                  // to know the position of the tab tag 
        tabStack.add(info);
        mTabStackMap.put(tag, tabStack);
        notifyDataSetChanged();
    }

    /**
     * Will add the Fragment to Tab with the Tag _tag. Provide the Class of the Fragment
     * it will be instantiated by this object. Proivde _args for your Fragment.
     * 
     * @param fm
     * @param _tag
     * @param _class
     * @param _args
     */
    public void addFragment(FragmentManager fm, String _tag, Class<?> _class, Bundle _args){
        TabInfo info = new TabInfo(_tag, _class, _args);
        Stack<TabInfo> tabStack = mTabStackMap.get(_tag);   
        Fragment frag = fm.findFragmentByTag("android:switcher:" + mViewPager.getId() + ":" + mTabTags.indexOf(_tag));
        if(frag instanceof SaveStateBundle){
            Bundle b = new Bundle();
            ((SaveStateBundle) frag).onRemoveFragment(b);
            tabStack.peek().args = b;
        }
        tabStack.add(info);
        FragmentTransaction ft = fm.beginTransaction();
        ft.remove(frag).commit();
        notifyDataSetChanged();
    }

    /**
     * Will pop the Fragment added to the Tab with the Tag _tag
     * 
     * @param fm
     * @param _tag
     * @return
     */
    public boolean popFragment(FragmentManager fm, String _tag){
        Stack<TabInfo> tabStack = mTabStackMap.get(_tag);   
        if(tabStack.size()>1){
            tabStack.pop();
            Fragment frag = fm.findFragmentByTag("android:switcher:" + mViewPager.getId() + ":" + mTabTags.indexOf(_tag));
            FragmentTransaction ft = fm.beginTransaction();
            ft.remove(frag).commit();
            notifyDataSetChanged();
            return true;
        }
        return false;
    }

    public boolean back(FragmentManager fm) {
        int position = mViewPager.getCurrentItem();
        return popFragment(fm, mTabTags.get(position));
    }

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

    @Override
    public int getItemPosition(Object object) {
        ArrayList<Class<?>> positionNoneHack = new ArrayList<Class<?>>();
        for(Stack<TabInfo> tabStack: mTabStackMap.values()){
            positionNoneHack.add(tabStack.peek().clss);
        }   // if the object class lies on top of our stacks, we return default
        if(positionNoneHack.contains(object.getClass())){
            return POSITION_UNCHANGED;
        }
        return POSITION_NONE;
    }

    @Override
    public Fragment getItem(int position) {
        Stack<TabInfo> tabStack = mTabStackMap.get(mTabTags.get(position));
        TabInfo info = tabStack.peek();
        return Fragment.instantiate(mContext, info.clss.getName(), info.args);
    }

    @Override
    public void onTabChanged(String tabId) {
        int position = mTabHost.getCurrentTab();
        mViewPager.setCurrentItem(position);
    }

    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
    }

    @Override
    public void onPageSelected(int position) {
        // Unfortunately when TabHost changes the current tab, it kindly
        // also takes care of putting focus on it when not in touch mode.
        // The jerk.
        // This hack tries to prevent this from pulling focus out of our
        // ViewPager.
        TabWidget widget = mTabHost.getTabWidget();
        int oldFocusability = widget.getDescendantFocusability();
        widget.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
        mTabHost.setCurrentTab(position);
        widget.setDescendantFocusability(oldFocusability);
    }

    @Override
    public void onPageScrollStateChanged(int state) {
    }

}

এই যোগ ব্যাক বোতাম আপনার MainActivity মধ্যে কার্যকারিতা:

@Override
public void onBackPressed() {
  if (!mTabsAdapter.back(getSupportFragmentManager())) {
    super.onBackPressed();
  }
}

আপনি যদি টুকরো টুকরো স্টেটটি সরিয়ে ফেলা সংরক্ষণ করতে চান । আপনার টুকরাটি SaveStateBundleফাংশনে ইন্টারফেসটি ফিরিয়ে আনতে আপনার সেভ স্টেটের সাথে একটি বান্ডিল প্রয়োগ করুন । দ্বারা ইনস্ট্যান্টেশন পরে বান্ডিল পান this.getArguments()

আপনি এটির মতো একটি ট্যাব ইনস্ট্যান্ট করতে পারেন :

mTabsAdapter.addTab(mTabHost.newTabSpec("firstTabTag").setIndicator("First Tab Title"),
                FirstFragmentActivity.FirstFragmentFragment.class, null);

আপনি যদি কোনও ট্যাব স্ট্যাকের শীর্ষে কোনও টুকরো যোগ করতে চান তবে একই সাথে কাজ করে। গুরুত্বপূর্ণ : আমি মনে করি, আপনি দুটি ট্যাবের উপরে একই শ্রেণির 2 টি উদাহরণ চাইলে এটি কার্যকর হবে না। আমি একসাথে এই সমাধানটি দ্রুত করেছি, সুতরাং এটির সাথে কোনও অভিজ্ঞতা না দিয়েই কেবল এটি ভাগ করতে পারি।


ব্যাক-বোতামটি চাপ দেওয়ার সময় আমি নালপয়েন্টার ব্যতিক্রম পাই এবং আমার প্রতিস্থাপনকৃত খণ্ডটিও দৃশ্যমান নয়। সুতরাং সম্ভবত আমি কিছু ভুল করছি: খণ্ডগুলি সঠিকভাবে পরিবর্তন করার জন্য সঠিক কলটি কী হওয়া উচিত?
জেরোইন

আপডেট: আমি বেশিরভাগ জিনিসগুলি স্থির করেছিলাম, তবে, আমি যদি কোনও নতুন টুকরো যোগ করার পরে যদি একটি ব্যাক-বোতাম চাপি এবং তার পরে অন্য ট্যাব এবং পিছনে যাই, আমি একটি নালপয়েন্টার ব্যতিক্রম পাই। সুতরাং আমার কাছে 2 টি প্রশ্ন রয়েছে: 1: আমি কীভাবে কোনও ট্যাবটির ইতিহাস সরাতে পারি এবং কেবলমাত্র সর্বশেষতম খণ্ডটি (তে স্ট্যাকের শীর্ষে) উপস্থিত রয়েছে তা নিশ্চিত করতে পারি? 2: নালপয়েন্টার ব্যতিক্রম থেকে আমি কীভাবে মুক্তি পাব?
জেরোইন

@ জিরোয়ান 1: আপনি এমট্যাবস্ট্যাকম্যাপ থেকে সঠিক স্ট্যাকটি পেতে পারেন এবং তারপরে স্ট্যাকের শীর্ষের নীচে থাকা প্রতিটি ট্যাবইনফো বস্তুটি সরিয়ে ফেলতে পারেন, 2: স্ট্যাকট্রেসের সাহায্যে একটি প্রশ্ন জিজ্ঞাসা করা খুব শক্ত, তবে আমি এটি জানতে চেষ্টা করতে পারি আপনি কি নিশ্চিত যে এটি আপনার কোডটিতে ব্যর্থতা নয়? আপনি যদি সরাসরি প্রতিবেশে (ডান বা বাম) কোনও ট্যাবে (এবং তারপরে ফিরে) স্যুইচ করেন তবে এটি কি ঘটবে?
সেপ্টেম্বর

ঠিক আছে, আমি একটি নতুন সমস্যার মধ্যে দৌড়েছি: আমি যদি আমার স্ক্রিনটি ঘোরান, তবে স্ট্যাকটি আবার খালি মনে হচ্ছে? এটি পূর্ববর্তী আইটেমগুলির ট্র্যাকগুলি আলগা মনে হচ্ছে ...
জেরোইন

1
@ সেব ধন্যবাদ আমি এই কোডটি ব্যবহার করছিলাম তবে নেস্টেড টুকরোগুলি এখন সম্ভব তাই আর সমস্যা নেই। :)
গারকন

2

ভিউপ্যাজারে টুকরোগুলি প্রতিস্থাপন করা বেশ জড়িত তবে এটি খুব সম্ভব এবং এটি সুপার স্লিক দেখতে পারে। প্রথমে, আপনাকে ভিউপাগার নিজেই টুকরোগুলি সরানো এবং যোগ করতে পরিচালনা করতে হবে। যখন আপনি অনুসন্ধানফ্র্যাগমেন্টের অভ্যন্তরে টুকরোটি প্রতিস্থাপন করবেন তখন যা ঘটছে তা হ'ল আপনার ভিউপিগারটি এর খণ্ডের দৃশ্যগুলি ধরে রাখে। সুতরাং আপনি একটি ফাঁকা পৃষ্ঠাতে শেষ করুন কারণ আপনি যখন এটি প্রতিস্থাপন করার চেষ্টা করবেন তখন অনুসন্ধানের অংশটি সরিয়ে ফেলা হবে।

সমাধানটি হ'ল আপনার ভিউপিজারের অভ্যন্তরে এমন একটি শ্রোতা তৈরি করা যা এর বাইরে হওয়া পরিবর্তনগুলি পরিচালনা করবে তাই প্রথমে আপনার অ্যাডাপ্টারের নীচে এই কোডটি যুক্ত করুন।

public interface nextFragmentListener {
    public void fragment0Changed(String newFragmentIdentification);
}

তারপরে আপনার ভিউপিজারে আপনাকে একটি প্রাইভেট ক্লাস তৈরি করতে হবে যা আপনি যখন নিজের খণ্ডটি পরিবর্তন করতে চান তখন শ্রোতা হয়ে উঠবে। উদাহরণস্বরূপ আপনি এই জাতীয় কিছু যুক্ত করতে পারেন। লক্ষ্য করুন যে এটি কেবলমাত্র তৈরি করা ইন্টারফেস প্রয়োগ করে। সুতরাং যখনই আপনি এই পদ্ধতিটি কল করবেন এটি নীচের শ্রেণীর অভ্যন্তরে কোডটি চালাবে।

private final class fragmentChangeListener implements nextFragmentListener {


    @Override
    public void fragment0Changed(String fragment) {
        //I will explain the purpose of fragment0 in a moment
        fragment0 = fragment;
        manager.beginTransaction().remove(fragAt0).commit();

        switch (fragment){
            case "searchFragment":
                fragAt0 = SearchFragment.newInstance(listener);
                break;
            case "searchResultFragment":
                fragAt0 = Fragment_Table.newInstance(listener);
                break;
        }

        notifyDataSetChanged();
    }

এখানে দু'টি প্রধান বিষয় উল্লেখ করতে হবে:

  1. ફ્રે্যাগএটি0 একটি "নমনীয়" খণ্ড। এটি আপনি যে কোনও খণ্ড খণ্ডন দিয়ে থাকেন তা গ্রহণ করতে পারে। এটি 0 টি অবস্থানে টুকরাটি আপনার পছন্দের খণ্ডে পরিবর্তন করতে আপনার সেরা বন্ধু হতে দেয়।
  2. শ্রোতাদের লক্ষ্য করুন যেগুলি 'নতুনআইন্সটেন্স (শ্রোতা) নির্মাত্রে স্থাপন করা হয়েছে। এগুলি আপনি কলফ্রেগমেন্ট 0 চেঞ্জড (স্ট্রিং নিউফ্র্যাগমেন্টআইডেন্টিফিকেশন) will ` নিম্নলিখিত কোডটি দেখায় যে কীভাবে আপনি আপনার খণ্ডের ভিতরে শ্রোতাদের তৈরি করেন।

    স্ট্যাটিক পরবর্তী

        public static Fragment_Journals newInstance(nextFragmentListener listener){
                listenerSearch = listener;
                return new Fragment_Journals();
            }

আপনি আপনার ভিতরে পরিবর্তন কল করতে পারেন onPostExecute

private class SearchAsyncTask extends AsyncTask<Void, Void, Void>{

    protected Void doInBackground(Void... params){
        .
        .//some more operation
        .
    }
    protected void onPostExecute(Void param){

        listenerSearch.fragment0Changed("searchResultFragment");
    }

}

এটি আপনার ভিউপাগারের অভ্যন্তরে কোডটি ট্রিগার করবে যাতে আপনার খণ্ডটি শূন্যের টুকরোতে নতুন সন্ধানের ফলাফল ফ্রেমে পরিণত হয় A আরও দুটি ছোট টুকরো রয়েছে যা ভিউপ্যাজারে কার্যকর হওয়ার আগে আপনাকে যুক্ত করতে হবে।

একটি ভিউপ্যাজারের getItem ওভাররাইড পদ্ধতিতে হবে।

@Override
public Fragment getItem(int index) {

    switch (index) {
    case 0:
        //this is where it will "remember" which fragment you have just selected. the key is to set a static String fragment at the top of your page that will hold the position that you had just selected.  

        if(fragAt0 == null){

            switch(fragment0){
            case "searchFragment":
                fragAt0 = FragmentSearch.newInstance(listener);
                break;
            case "searchResultsFragment":
                fragAt0 = FragmentSearchResults.newInstance(listener);
                break;
            }
        }
        return fragAt0;
    case 1:
        // Games fragment activity
        return new CreateFragment();

    }

এখন এই চূড়ান্ত টুকরো ছাড়া আপনি একটি ফাঁকা পৃষ্ঠা পাবেন। খোঁড়া ধরনের, কিন্তু এটি ভিউপ্যাজারের একটি অপরিহার্য অঙ্গ। আপনাকে অবশ্যই ভিউপ্যাজারের getItemPosition পদ্ধতিটি ওভাররাইড করতে হবে। সাধারণত এই পদ্ধতিটি POSITION_UNCHANGED ফিরিয়ে দেবে যা ভিউপজারকে সব কিছু একই রাখার জন্য বলে এবং তাই আইটেমটি নতুন খণ্ডটিকে পৃষ্ঠায় রাখার জন্য কখনও কল করা হবে না। এখানে আপনি করতে পারেন এমন একটি উদাহরণ's

public int getItemPosition(Object object)
{
    //object is the current fragment displayed at position 0.  
    if(object instanceof SearchFragment && fragAt0 instanceof SearchResultFragment){
        return POSITION_NONE;
    //this condition is for when you press back
    }else if{(object instanceof SearchResultFragment && fragAt0 instanceof SearchFragment){
        return POSITION_NONE;
    }
        return POSITION_UNCHANGED
}

যেমনটি আমি বলেছিলাম, কোডটি খুব জড়িত, তবে আপনাকে মূলত আপনার পরিস্থিতির জন্য একটি কাস্টম অ্যাডাপ্টার তৈরি করতে হবে। আমি যে জিনিসগুলি উল্লেখ করেছি সেগুলি খণ্ডটি পরিবর্তন করা সম্ভব করবে। সব কিছু ভিজিয়ে রাখতে সম্ভবত অনেক দিন সময় লাগবে তাই আমি ধৈর্য ধরব, তবে এটি সমস্ত অর্থবোধ করবে। সময়টি পুরোপুরি মূল্যবান কারণ এটি সত্যিই চটজলদি অ্যাপ্লিকেশন তৈরি করতে পারে।

পিছনের বোতামটি হ্যান্ডল করার জন্য এখানে নুগেট। আপনি এটিকে আপনার মূল কার্যকলাপের ভিতরে রেখেছেন inside

 public void onBackPressed() {
    if(mViewPager.getCurrentItem() == 0) {
        if(pagerAdapter.getItem(0) instanceof FragmentSearchResults){
            ((Fragment_Table) pagerAdapter.getItem(0)).backPressed();
        }else if (pagerAdapter.getItem(0) instanceof FragmentSearch) {
            finish();
        }
    }

আপনাকে ফ্রেগমেন্টসাইসারসাল্টস এর অভ্যন্তরে ব্যাকপ্রেসড () নামে একটি পদ্ধতি তৈরি করতে হবে যা ফ্রেগমেন্ট0 -র পরিবর্তিতকে কল করে। এটি কোডের সাথে সামঞ্জস্য রেখে আমি এর আগে দেখিয়েছি পিছনের বোতামটি টিপুন। আপনার কোডটির সাথে ভিউপিজারটি পরিবর্তন করার জন্য শুভকামনা। এটি অনেক কাজ নেয়, এবং যতদূর আমি খুঁজে পেয়েছি, কোনও দ্রুত অভিযোজন নেই। যেমনটি আমি বলেছিলাম, আপনি মূলত একটি কাস্টম ভিউপেজার অ্যাডাপ্টার তৈরি করছেন এবং শ্রোতাদের ব্যবহার করে এটি প্রয়োজনীয় সমস্ত পরিবর্তন পরিচালনা করতে দিচ্ছেন


এই সমাধানের জন্য আপনাকে ধন্যবাদ। তবে স্ক্রিনটি ঘোরানোর পরে আপনার কোনও সমস্যা হয়েছে? আমি যখন স্ক্রিনটি ঘোরালাম এবং একই ট্যাবে অন্য একটি খণ্ড পুনরায় লোড করার চেষ্টা করছিলাম তখন আমার অ্যাপ্লিকেশানটি ক্রাশ হয়।
AnteGemini

অ্যান্ড্রয়েড ডেভ করে ফেলেছি কিছুক্ষণ হয়ে গেছে, তবে আমার ধারণা হ'ল এমন এক টুকরো ডেটা রয়েছে যা আপনার অ্যাপটি গণনা করছে না। আপনি যখন ঘোরান, সম্পূর্ণ ক্রিয়াকলাপটি পুনরায় চালু হয় এবং আপনার প্রয়োজনীয় সমস্ত ডেটা ছাড়াই আপনার পূর্ববর্তী অবস্থাটি পুনরায় লোড করার চেষ্টা করলে ক্রাশ হতে পারে (
অনপস, অন রিসুমে

2

এটি অর্জনের জন্য এটি আমার উপায়।

প্রথমে আপনি যে ট্যাবটিতে বাটন ক্লিক ইভেন্টটি প্রয়োগ করতে চান তাতে ট্যাবটির Root_fragmentভিতরে যুক্ত viewPagerকরুন fragment। উদাহরণ;

@Override
public Fragment getItem(int position) {
  if(position==0)
      return RootTabFragment.newInstance();
  else
      return SecondPagerFragment.newInstance();
}

প্রথমত, খণ্ড পরিবর্তনের জন্য RootTabFragmentঅন্তর্ভুক্ত করা উচিত FragmentLayout

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:id="@+id/root_frame"
   android:layout_width="match_parent"
   android:layout_height="match_parent">
</FrameLayout>

তারপরে, ভিতরে RootTabFragment onCreateView, fragmentChangeআপনার জন্য বাস্তবায়ন করুনFirstPagerFragment

getChildFragmentManager().beginTransaction().replace(R.id.root_frame, FirstPagerFragment.newInstance()).commit();

এর পরে, onClickভিতরে আপনার বোতামটির জন্য ইভেন্টটি বাস্তবায়ন করুন FirstPagerFragmentএবং এর মতো খণ্ডিত পরিবর্তন আবার করুন।

getChildFragmentManager().beginTransaction().replace(R.id.root_frame, NextFragment.newInstance()).commit();

আশা করি এটি আপনাকে সাহায্য করবে।


1

আমি সহজ সমাধান পেয়েছি, যা আপনি মাঝখানে নতুন টুকরো যুক্ত করতে বা বর্তমান খণ্ডটি প্রতিস্থাপন করতে চাইলেও ঠিক কাজ করে। আমার সমাধানে আপনার ওভাররাইড করা উচিত getItemId()যা প্রতিটি খণ্ডের জন্য স্বতন্ত্র আইডি ফিরিয়ে আনতে হবে। ডিফল্ট হিসাবে অবস্থান নয়।

এই যে এইটা:

public class DynamicPagerAdapter extends FragmentPagerAdapter {

private ArrayList<Page> mPages = new ArrayList<Page>();
private ArrayList<Fragment> mFragments = new ArrayList<Fragment>();

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

public void replacePage(int position, Page page) {
    mPages.set(position, page);
    notifyDataSetChanged();
}

public void setPages(ArrayList<Page> pages) {
    mPages = pages;
    notifyDataSetChanged();
}

@Override
public Fragment getItem(int position) {
    if (mPages.get(position).mPageType == PageType.FIRST) {
        return FirstFragment.newInstance(mPages.get(position));
    } else {
        return SecondFragment.newInstance(mPages.get(position));
    }
}

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

@Override
public long getItemId(int position) {
    // return unique id
    return mPages.get(position).getId();
}

@Override
public Object instantiateItem(ViewGroup container, int position) {
    Fragment fragment = (Fragment) super.instantiateItem(container, position);
    while (mFragments.size() <= position) {
        mFragments.add(null);
    }
    mFragments.set(position, fragment);
    return fragment;
}

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
    super.destroyItem(container, position, object);
    mFragments.set(position, null);
}

@Override
public int getItemPosition(Object object) {
    PagerFragment pagerFragment = (PagerFragment) object;
    Page page = pagerFragment.getPage();
    int position = mFragments.indexOf(pagerFragment);
    if (page.equals(mPages.get(position))) {
        return POSITION_UNCHANGED;
    } else {
        return POSITION_NONE;
    }
}
}

বিজ্ঞপ্তি: এই উদাহরণে FirstFragmentএবং SecondFragmentবিমূর্ত শ্রেণি পৃষ্ঠাফ্রেগমেন্ট প্রসারিত করে, যার পদ্ধতি রয়েছে getPage()


1

আমি ওয়াইজের সাথে অনুরূপ কিছু করছি তবে আমার উত্তরে আপনি যখনই চাইবেন দুটি টুকরাটির মধ্যে পরিবর্তন করতে পারবেন। এবং ওয়াইজের উত্তর দিয়ে আমার কিছু সমস্যা হয় যখন স্ক্রিনের ওরিয়েন্টেশনকে পরিবর্তন করতে হয় things এটি পেজারএডাপ্টারের মতো দেখাচ্ছে:

    public class MyAdapter extends FragmentPagerAdapter
{
    static final int NUM_ITEMS = 2;
    private final FragmentManager mFragmentManager;
    private Fragment mFragmentAtPos0;
     private Map<Integer, String> mFragmentTags;
     private boolean isNextFragment=false;

    public MyAdapter(FragmentManager fm)
    {
        super(fm);
        mFragmentManager = fm;
         mFragmentTags = new HashMap<Integer, String>();
    }

    @Override
    public Fragment getItem(int position)
    {
        if (position == 0)
        {


            if (isPager) {
                mFragmentAtPos0 = new FirstPageFragment();
            } else {
                mFragmentAtPos0 = new NextFragment();
            }
            return mFragmentAtPos0;
        }
        else
            return SecondPageFragment.newInstance();
    }

    @Override
    public int getCount()
    {
        return NUM_ITEMS;
    }


 @Override
    public Object instantiateItem(ViewGroup container, int position) {
        Object obj = super.instantiateItem(container, position);
        if (obj instanceof Fragment) {
            // record the fragment tag here.
            Fragment f = (Fragment) obj;
            String tag = f.getTag();
            mFragmentTags.put(position, tag);
        }
        return obj;
    }


    public void onChange(boolean isNextFragment) {

        if (mFragmentAtPos0 == null)
            mFragmentAtPos0 = getFragment(0);
        if (mFragmentAtPos0 != null)
            mFragmentManager.beginTransaction().remove(mFragmentAtPos0).commit();


        if (!isNextFragment) {
            mFragmentAtFlashcards = new FirstPageFragment();
        } else {
            mFragmentAtFlashcards = new NextFragment();
        }

        notifyDataSetChanged();


    }


    @Override
    public int getItemPosition(Object object)
    {
        if (object instanceof FirstPageFragment && mFragmentAtPos0 instanceof NextFragment)
            return POSITION_NONE;
         if (object instanceof NextFragment && mFragmentAtPos0 instanceof FirstPageFragment)
            return POSITION_NONE;
        return POSITION_UNCHANGED;
    }


    public Fragment getFragment(int position) {
        String tag = mFragmentTags.get(position);
        if (tag == null)
            return null;
        return mFragmentManager.findFragmentByTag(tag);
    }
}

শ্রোতা আমি অ্যাডাপ্টারের ধারক ক্রিয়াকলাপে এটি প্রয়োগ করার সময় টুকরো টুকরো করার জন্য প্রয়োগ করেছি, এটি ক্রিয়াকলাপ:

    public class PagerContainerActivity extends AppCompatActivity implements ChangeFragmentListener {

//...

  @Override
    public void onChange(boolean isNextFragment) {
        if (pagerAdapter != null)
            pagerAdapter.onChange(isNextFragment);


    }

//...
}

তারপরে শ্রোতাকে যখন কোনও কলিং সংযুক্ত করা হয় তখন অংশে রাখুন:

public class FirstPageFragment extends Fragment{


private ChangeFragmentListener changeFragmentListener;


//...
 @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        changeFragmentListener = ((PagerContainerActivity) activity);
    }

    @Override
    public void onDetach() {
        super.onDetach();
        changeFragmentListener = null;
    }
//...
//in the on click to change the fragment
changeFragmentListener.onChange(true);
//...
}

এবং অবশেষে শ্রোতা:

public interface changeFragmentListener {

    void onChange(boolean isNextFragment);

}

1

আমি উত্তরগুলি @wize এবং @mdelolmo দ্বারা অনুসরণ করেছি এবং আমি সমাধান পেয়েছি। ধন্যবাদ টনস তবে, আমি মেমরির ব্যবহারের উন্নতি করতে এই সমাধানগুলিকে কিছুটা টিউন করেছি।

সমস্যাগুলি আমি পর্যবেক্ষণ করেছি:

তারা Fragmentপ্রতিস্থাপন করা হয় যা উদাহরণ সংরক্ষণ করুন । আমার ক্ষেত্রে এটি একটি টুকরা যা রাখে MapViewএবং আমি এটি ব্যয়বহুল বলে ভেবেছিলাম। সুতরাং, আমি নিজের FragmentPagerPositionChanged (POSITION_NONE or POSITION_UNCHANGED)পরিবর্তে রক্ষণাবেক্ষণ করছি Fragment

এখানে আমার বাস্তবায়ন।

  public static class DemoCollectionPagerAdapter extends FragmentStatePagerAdapter {

    private SwitchFragListener mSwitchFragListener;
    private Switch mToggle;
    private int pagerAdapterPosChanged = POSITION_UNCHANGED;
    private static final int TOGGLE_ENABLE_POS = 2;


    public DemoCollectionPagerAdapter(FragmentManager fm, Switch toggle) {
        super(fm);
        mToggle = toggle;

        mSwitchFragListener = new SwitchFragListener();
        mToggle.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                mSwitchFragListener.onSwitchToNextFragment();
            }
        });
    }

    @Override
    public Fragment getItem(int i) {
        switch (i)
        {
            case TOGGLE_ENABLE_POS:
                if(mToggle.isChecked())
                {
                    return TabReplaceFragment.getInstance();
                }else
                {
                    return DemoTab2Fragment.getInstance(i);
                }

            default:
                return DemoTabFragment.getInstance(i);
        }
    }

    @Override
    public int getCount() {
        return 5;
    }

    @Override
    public CharSequence getPageTitle(int position) {
        return "Tab " + (position + 1);
    }

    @Override
    public int getItemPosition(Object object) {

        //  This check make sures getItem() is called only for the required Fragment
        if (object instanceof TabReplaceFragment
                ||  object instanceof DemoTab2Fragment)
            return pagerAdapterPosChanged;

        return POSITION_UNCHANGED;
    }

    /**
     * Switch fragments Interface implementation
     */
    private final class SwitchFragListener implements
            SwitchFragInterface {

        SwitchFragListener() {}

        public void onSwitchToNextFragment() {

            pagerAdapterPosChanged = POSITION_NONE;
            notifyDataSetChanged();
        }
    }

    /**
     * Interface to switch frags
     */
    private interface SwitchFragInterface{
        void onSwitchToNextFragment();
    }
}

ডেমো লিঙ্কটি এখানে .. https://youtu.be/l_62uhKkLyM

ডেমো উদ্দেশ্যে, ব্যবহৃত 2 টুকরা TabReplaceFragmentএবং DemoTab2Fragmentদ্বিতীয় অবস্থানে। অন্যান্য সমস্ত ক্ষেত্রে আমি DemoTabFragmentউদাহরণ ব্যবহার করছি ।

ব্যাখ্যা:

আমি পার করছি Switchভ্রমণ থেকে DemoCollectionPagerAdapter। এই স্যুইচের অবস্থার উপর ভিত্তি করে আমরা সঠিক খণ্ডটি প্রদর্শন করব। যখন সুইচ চেক পরিবর্তন করা হয়, আমি ফোন দিচ্ছি SwitchFragListener'র onSwitchToNextFragmentপদ্ধতি, যেখানে আমি এর মান পরিবর্তন করছি pagerAdapterPosChangedপরিবর্তনশীল POSITION_NONEPOSITION_NONE সম্পর্কে আরও দেখুন । এটি getItemটিকে অকার্যকর করবে এবং আমার ডানদিকে সঠিক অংশটি ইনস্ট্যান্ট করতে হবে log দুঃখিত, ব্যাখ্যাটি যদি কিছুটা অগোছালো হয়।

আসল ধারণার জন্য আবারও @wize এবং @mdelolmo ধন্যবাদ জানাই।

আশা করি এটি সহায়ক। :)

যদি এই বাস্তবায়নের কোনও ত্রুটি থাকে তবে আমাকে জানান। এটি আমার প্রকল্পের জন্য সহায়ক হবে।


0

গবেষণার পরে আমি শর্ট কোড সহ সমাধান পেয়েছি। প্রথমে খণ্ডে একটি সর্বজনীন উদাহরণ তৈরি করুন এবং যদি অরিয়েন্টেশন পরিবর্তনে পুনরায় অংশ না করা হয় তবে কেবলমাত্র সেভইনস্ট্যান্সস্টেটে আপনার টুকরোটি সরিয়ে ফেলুন।

 @Override
public void onSaveInstanceState(Bundle outState) {
    if (null != mCalFragment) {
        FragmentTransaction bt = getChildFragmentManager().beginTransaction();
        bt.remove(mFragment);
        bt.commit();
    }
    super.onSaveInstanceState(outState);
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.