Question

I’ve used AsyncTaskLoader to load a cursor from a database query.
I followed Android Developers sample:
http://developer.android.com/reference/android/content/AsyncTaskLoader.html

But somehow the fragments that being added to the page adapter after this fragment (which uses the loader) doesn’t get attached to the activity and when it tries to use methods that need an activity (like getString()) an exception is being thrown and says that this fragment isn’t attached to any activity.

Here is some code:

1. Adding the fragments to the page adapter.

   mAdapter = new PlaceFragmentPagerAdapter(getSupportFragmentManager());
   
   
   NewFragment newFrag = new NewFragment();
   mAdapter.addFragment(newShiftFrag);
   
   ListFragment listFrag = new ListFragment();
   mAdapter.addFragment(listFrag);
   
   SettingsFragment settingsFrag = new SettingsFragment();
   mAdapter.addFragment(settingsFrag);
   
   mPager = (ViewPager)findViewById(R.id.pager);
   mPager.setAdapter(mAdapter);
   

2. AsyncTaskLoader implementation:

   abstract public class AbstractCursorLoader extends AsyncTaskLoader {

       abstract protected Cursor buildCursor();
       Cursor lastCursor=null;
   
       public AbstractCursorLoader(Context context) {
           super(context);
       }
   
       /** 
        * Runs on a worker thread, loading in our data. Delegates
        * the real work to concrete subclass' buildCursor() method. 
        */
       @Override
       public Cursor loadInBackground() {
           Cursor cursor=buildCursor();
   
           if (cursor!=null) {
               // Ensure the cursor window is filled
               cursor.getCount();
           }
   
           return(cursor);
       }
   
       /**
        * Runs on the UI thread, routing the results from the
        * background thread to whatever is using the Cursor
        * (e.g., a CursorAdapter).
        */
       @Override
       public void deliverResult(Cursor cursor) {
           if (isReset()) {
               // An async query came in while the loader is stopped
               if (cursor!=null) {
                   cursor.close();
               }
   
               return;
           }
   
           Cursor oldCursor=lastCursor;
           lastCursor=cursor;
   
           if (isStarted()) {
               super.deliverResult(cursor);
           }
   
           if (oldCursor!=null && oldCursor!=cursor && !oldCursor.isClosed()) {
               oldCursor.close();
           }
       }
   
       /**
        * Starts an asynchronous load of the list data.
        * When the result is ready the callbacks will be called
        * on the UI thread. If a previous load has been completed
        * and is still valid the result may be passed to the
        * callbacks immediately.
        * 
        * Must be called from the UI thread.
        */
       @Override
       protected void onStartLoading() {
           if (lastCursor!=null) {
               deliverResult(lastCursor);
           }
           if (takeContentChanged() || lastCursor==null) {
               forceLoad();
           }
       }
   
       /**
        * Must be called from the UI thread, triggered by a
        * call to stopLoading().
        */
       @Override
       protected void onStopLoading() {
           // Attempt to cancel the current load task if possible.
           cancelLoad();
       }
   
       /**
        * Must be called from the UI thread, triggered by a
        * call to cancel(). Here, we make sure our Cursor
        * is closed, if it still exists and is not already closed.
        */
       @Override
       public void onCanceled(Cursor cursor) {
           if (cursor!=null && !cursor.isClosed()) {
               cursor.close();
           }
       }
   
       /**
        * Must be called from the UI thread, triggered by a
        * call to reset(). Here, we make sure our Cursor
        * is closed, if it still exists and is not already closed.
        */
       @Override
       protected void onReset() {
           super.onReset();
   
           // Ensure the loader is stopped
           onStopLoading();
   
           if (lastCursor!=null && !lastCursor.isClosed()) {
               lastCursor.close();
           }
   
           lastCursor=null;
       }
   }
   
       private static class ListLoader extends AbstractCursorLoader {
           private String mName;
   
           public ShiftsListLoader(Context context, String name) {
               super(context);
               mName = name;
           }
   
           @Override
           protected Cursor buildCursor() {
               PlacesHandler wph = new PlacesHandler(this.getContext());
               return wph.GetShifts(mName);
           }
       }
   

3. Initializng the loader:

       @Override 
       public void onActivityCreated(Bundle savedInstanceState) {
       super.onActivityCreated(savedInstanceState);
   
       // Give some text to display if there is no data.  In a real
       // application this would come from a resource.
       // TODO change to resource and back
       setEmptyText("Nothing here..");
   
       // Start out with a progress indicator.
       setListShown(false);
   
   
   
       // Prepare the loader.  Either re-connect with an existing one,
       // or start a new one.
       getLoaderManager().initLoader(0, null, this);
   

   }

       @Override
       public Loader<Cursor> onCreateLoader(int id, Bundle args) {
           return new ListLoader(getActivity(), mWorkPlaceName);
       }
       @Override
       public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
           // Create an empty adapter we will use to display the loaded data.
       mAdapter = new ListCursorAdapter(getActivity(), data, CursorAdapter.FLAG_REGISTER_CONTENT_OBSERVER);
       setListAdapter(mAdapter);
   
       }
   @Override
   public void onLoaderReset(Loader<Cursor> loader) {
       // TODO Auto-generated method stub
   
   }
   

I really don’t have a clue why is it happening.

P.S. I had some problems making the code blocks in the comment I thing it has a bug, so sorry.

Thanks in advance, Elad.

Answer 1

The short answer is that you should never assume a fragment is in any specific state until it receives the appropriate lifecycle callback signaling it.

What you’re seeing is an optimization added during ICS that ViewPager takes advantage of. FragmentPagerAdapter specially marks offscreen fragments as not being user-visible by calling setUserVisibleHint. The FragmentManager uses this to prioritize how loaders are executed so that the user will see the fully loaded visible page first, and loading side pages does not slow down the process of loading the visible page. Specifically, it delays moving the fragment into the “started” state, which is also when loaders start running.

If the user scrolls over to another page while this is in process the FragmentManager will move the fragment into the started state and begin running its loaders immediately as part of FragmentPagerAdapter#setPrimaryItem(), since this method marks the current page as now being user-visible.