टुकड़े लेनदेन का प्रबंधन जहां आप कुछ टुकड़ों के लिए डेटा खोना नहीं चाहते हैं

Question

मेरे पास 5 टुकड़े हैं, जिनमें से दो सूची टुकड़े हैं जिनमें कुछ डेटा (महंगी लोडिंग) है और उनमें से बाकी के पास कुछ भी महत्वपूर्ण नहीं है।

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

वर्कफ़्लो: मुख्य टुकड़ा (कार्य टुकड़ा) बाद में लोड किया जा सकता है किसी भी टुकड़े को लोड किया जा सकता है। यदि मुख्य टुकड़ा वर्तमान है और समूह खंड का चयन किया गया है तो मुख्य खंड को हटा दें अन्यथा यदि कोई अन्य टुकड़ा चुना जाता है तो मुख्य खंड को बनाए रखें (छुपाएं) और नए टुकड़े को लोड करें

नोट: इसका उपयोग नेविगेशन ड्रॉवर के साथ किया जाता है जहां 1 खंड

public class FragmentController { 

    private static final String TAG_MAIN = "main"; //Expensive 
    private static final String TAG_GROUP = "group"; //Expensive 
    private static final String TAG_PROFILE = "profile"; //Cheap 
    private static final String TAG_CREATE_TASK = "create_task"; //Cheap 
    private static final String TAG_CREATE_GROUP = "create_group";//Cheap 
    private static final String TAG_SETTINGS = "settings"; //Cheap 

    private android.support.v4.app.FragmentManager fragmentManager; 


    @IdRes private int container; 

    public FragmentController(android.support.v4.app.FragmentManager fragmentManager, @IdRes int container) { 
     this.fragmentManager = fragmentManager; 
     this.container = container; 
    } 

    public void showMainFragment() { 
     FragmentTransaction transaction = fragmentManager.beginTransaction(); 
     if (containsMainFragment()) { 
      if (!isMainCurrent()) { 
       transaction 
         .show(getMainFragment()) 
         .commit(); 
      } 
     } else { 
      transaction 
        .replace(container, getMainFragment(), TAG_MAIN) 
        .commit(); 
     } 
    } 

    public void showGroupFragment() { 
     FragmentTransaction transaction = fragmentManager.beginTransaction(); 
     if (containsGroupFragment()) { 
      if (!isGroupCurrent()) { 
       transaction 
         .show(getGroupFragment()) 
         .commit(); 
      } 
     } else { 
      transaction 
        .replace(container, getGroupFragment(), TAG_GROUP) 
        .commit(); 
     } 
    } 

    public void showProfileFragment() { 
     showLightFragment(ProfileFragment.newInstance(), TAG_PROFILE); 
    } 

    public void showCreateTaskFragment() { 
     showLightFragment(CreateTaskFragment.newInstance(), TAG_CREATE_TASK); 
    } 

    public void showCreateGroupFragment() { 
     showLightFragment(CreateGroupFragment.newInstance(), TAG_CREATE_GROUP); 
    } 

    public void showSettingsFragment() { 
     showLightFragment(SettingsFragment.newInstance(), TAG_SETTINGS); 
    } 

    private void showLightFragment(Fragment fragmentInstance, String tag) { 
     FragmentTransaction transaction = fragmentManager.beginTransaction(); 
     Fragment fragment = getCurrentFragment(); 
     if (containsListFragment() && (isMainCurrent() || isGroupCurrent())) { 
      assert fragment != null; 
      transaction = transaction 
          .hide(fragment) 
          .add(container, fragmentInstance, tag) 
          .addToBackStack(tag); 
     } else { 
      transaction = transaction 
          .remove(fragment) 
          .add(container, fragmentInstance, tag); 
     } 
     if(isCreateTaskFragment(fragment)){ 

      transaction = transaction 
        .addToBackStack(tag); 
     } 
     transaction.commit(); 
    } 

    private boolean containsListFragment() { 
     return getFragmentByTag(TAG_MAIN) != null || getFragmentByTag(TAG_GROUP) != null; 
    } 

    private boolean containsMainFragment() { 
     return getFragmentByTag(TAG_MAIN) != null; 
    } 

    private boolean containsGroupFragment() { 
     return getFragmentByTag(TAG_GROUP) != null; 
    } 

    private Fragment getMainFragment() { 
     Fragment fragment = getFragmentByTag(TAG_MAIN); 
     if (fragment == null) { 
      fragment = TasksFragment.newInstance(); 
     } 
     return fragment; 
    } 

    private Fragment getGroupFragment() { 
     Fragment fragment = getFragmentByTag(TAG_GROUP); 
     if (fragment == null) { 
      fragment = GroupTasksFragment.newInstance(); 
     } 
     return fragment; 
    } 

    private Fragment getFragmentByTag(String tag) { 
     return fragmentManager.findFragmentByTag(tag); 
    } 

    private Fragment getCurrentFragment() { 
     return fragmentManager.findFragmentById(container); 
    } 

    private boolean isMainCurrent() { return isCurrent(TAG_MAIN); } 

    private boolean isGroupCurrent() { 
     return isCurrent(TAG_GROUP); 
    } 

    private boolean isCurrent(String tag) { 
     Fragment fragment = getCurrentFragment(); 
     return fragment != null && fragment.getTag() != null && fragment.getTag().equals(tag); 
    } 

    private boolean isCreateTaskFragment(Fragment fragment){ 
     return fragment!=null && fragment.getTag()!=null && fragment.getTag().equals(TAG_CREATE_TASK); 
    } 

} 

Answer 1

खैर मुद्दा बसता था, लेकिन मैं एक गतिविधि के साथ CreateTaskFragment (जो समस्या थी) की जगह समाप्त हो गया।

Answer 2

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

@Override 
public void onBackPressed() { 
    if (getSupportFragmentManager().getBackStackEntryCount() > 0) { 
     getSupportFragmentManager().popBackStack(); 
    } else { 
     super.onBackPressed(); 
    } 
} 

विवरण यहाँ देखें आप के लिए सब कुछ करना होगा: Performing Fragment Transactions