CursorLoader usage without ContentProvider

Question

Android SDK documentation says that startManagingCursor() method is depracated:

This method is deprecated. Use the new CursorLoader class with LoaderManager instead; this is also available on older platforms through the Android compatibility package. This method allows the activity to take care of managing the given Cursor's lifecycle for you based on the activity's lifecycle. That is, when the activity is stopped it will automatically call deactivate() on the given Cursor, and when it is later restarted it will call requery() for you. When the activity is destroyed, all managed Cursors will be closed automatically. If you are targeting HONEYCOMB or later, consider instead using LoaderManager instead, available via getLoaderManager()

So I would like to use CursorLoader. But how can I use it with custom CursorAdapter and without ContentProvider, when I needs URI in constructor of CursorLoader?

Mysticism

Answer 1

I wrote a simple CursorLoader that does not need a content provider:

import android.content.Context;
import android.database.Cursor;
import android.support.v4.content.AsyncTaskLoader;

/**
 * Used to write apps that run on platforms prior to Android 3.0. When running
 * on Android 3.0 or above, this implementation is still used; it does not try
 * to switch to the framework's implementation. See the framework SDK
 * documentation for a class overview.
 *
 * This was based on the CursorLoader class
 */
public abstract class SimpleCursorLoader extends AsyncTaskLoader<Cursor> {
    private Cursor mCursor;

    public SimpleCursorLoader(Context context) {
        super(context);
    }

    /* Runs on a worker thread */
    @Override
    public abstract Cursor loadInBackground();

    /* Runs on the UI thread */
    @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 = mCursor;
        mCursor = cursor;

        if (isStarted()) {
            super.deliverResult(cursor);
        }

        if (oldCursor != null && oldCursor != cursor && !oldCursor.isClosed()) {
            oldCursor.close();
        }
    }

    /**
     * Starts an asynchronous load of the contacts 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.
     * <p/>
     * Must be called from the UI thread
     */
    @Override
    protected void onStartLoading() {
        if (mCursor != null) {
            deliverResult(mCursor);
        }
        if (takeContentChanged() || mCursor == null) {
            forceLoad();
        }
    }

    /**
     * Must be called from the UI thread
     */
    @Override
    protected void onStopLoading() {
        // Attempt to cancel the current load task if possible.
        cancelLoad();
    }

    @Override
    public void onCanceled(Cursor cursor) {
        if (cursor != null && !cursor.isClosed()) {
            cursor.close();
        }
    }

    @Override
    protected void onReset() {
        super.onReset();

        // Ensure the loader is stopped
        onStopLoading();

        if (mCursor != null && !mCursor.isClosed()) {
            mCursor.close();
        }
        mCursor = null;
    }
}

It only needs the AsyncTaskLoader class. Either the one in Android 3.0 or higher, or the one that comes with the compatibility package.

I also wrote a ListLoader which is compatible with the LoadManager and is used to retrieve a generic java.util.List collection.

Romanaromanas

Found a nice code example that uses this - bitbucket.org/ssutee/418496_mobileapp/src/fc5ee705a2fd/demo/… - found it very useful ! – Pyjamas

@Romanaromanas Thanks for the example. What is the license associated with your class. How can it be reused? – Psychosexual

License is Apache 2.0; you can reuse it where/when ever you want. Let me know if you have any improvements. – Romanaromanas

Great stuff! Users should be aware of one limitation, which is that it has no mechanism to refresh on data changes (as Loaders are supposed to do) – Myriapod

How can Activity or Fragment be notified when Cursor changed? My CursorLoader is same as this, and on loadInBackground I have registed an Observer but never be notified when data change. – Prosperus

The same problem for me. I get no notitifications on data change with this class. – Spermato

Would you like to provide a simple example usage of this class? – Allayne

@Romanaromanas - Thank you for you help...can you please direct me to the ListLoader you wrote? the link here does not work. Thanx – Belew

@Belew here you have man: ListLoader and SupportListLoader – Romanaromanas

Answer 2

Write your own loader that uses your database class instead of a content provider. The easiest way is just to take the source of the CursorLoader class from the compatibility library, and replace provider queries with queries to your own db helper class.

Exact

This is is the easiest way in my opinion. In my app I created a CursorLoader descendat to manage a SQLite cursor, appart from the constructor I only needed to override the loadInBackground method to replace the provider query with my cursor query – Balanchine

Answer 3

The SimpleCursorLoader is a simple solution, however it doesn't support updating the loader when the data changes. CommonsWare has a loaderex library that adds a SQLiteCursorLoader and supports re-query on data changes.

https://github.com/commonsguy/cwac-loaderex

Myriapod

However, to make use of the automatic re-querying, you need to use the same loader for the UI as well as for the updates, limiting its usability for background services. – Euphonium

Answer 4

A third option would be to simply override loadInBackground:

public class CustomCursorLoader extends CursorLoader {
    private final ForceLoadContentObserver mObserver = new ForceLoadContentObserver();

    @Override
    public Cursor loadInBackground() {
        Cursor cursor = ... // get your cursor from wherever you like

        if (cursor != null) {
            // Ensure the cursor window is filled
            cursor.getCount();
            cursor.registerContentObserver(mObserver);
        }

        return cursor;
    }
};

This will also take care of re-querying your cursor when the database changes.

Only caveat: You'll have to define another observer, since Google in it's infinite wisdom decided to make theirs package private. If you put the class into the same package as the original one (or the compat one) you can actually use the original observer. The observer is a very lightweight object and isn't used anywhere else, so this doesn't make much of a difference.

Glaive

My observation in quick testing is that registerContentObserver will only be called against the cursor if the cursor is targeted to a Content Provider. Can you confirm/deny this? – Performing

It doesn't necessarily have to be a ContentProvider. But the cursor needs to be registered to a notification uri (setNotificationUri), and it then needs to be notified by someone (usually a ContentProvider, but can be anything) by calling ContentResolver.notifyChange. – Glaive

Yeah. on your CustomLoader's loadInBackground() , before return the cursor, say cursor.setNotificationUri(getContext().getContentResolver(), uri); the uri may just from random String like Uri.parse("content://query_slot1"). Seem like it don't care the uri really exist or not. And once I done operation on DB. Say getContentResolver().notifyChange(uri, null); would do the trick. Then I may create few "query uri slot" in a contant file for app with small number of query. I test insert the DB record in runtime and it seems work but I still doubt it is good practice onit. Any suggestion? – Debark

I'm using this method with @Debark 's suggestion and everything works, including automatic reloading of the cursor on database update. – Brooksbrookshire

doesnt need it any unregisterContentObserver? – Sherrod

Answer 5

The third option proposed by Timo Ohr, together with the comments by Yeung, provide the simplest answer (Occam's razor). Below is an example of a complete class that works for me. There are two rules for using this class.

1. Extend this abstract class and implement methods getCursor() and getContentUri().

2. Any time that the underlying database changes (e.g., after an insert or delete), make sure to call

   getContentResolver().notifyChange(myUri, null);
   

   where myUri is the same one returned from your implementation of method getContentUri().

Here is the code for the class that I used:

package com.example.project;

import android.content.Context;
import android.database.Cursor;
import android.content.CursorLoader;
import android.content.Loader;

public abstract class AbstractCustomCursorLoader extends CursorLoader
  {
    private final Loader.ForceLoadContentObserver mObserver = new Loader.ForceLoadContentObserver();

    public AbstractCustomCursorLoader(Context context)
      {
        super(context);
      }

    @Override
    public Cursor loadInBackground()
      {
        Cursor cursor = getCursor();

        if (cursor != null)
          {
            // Ensure the cursor window is filled
            cursor.getCount();
            cursor.registerContentObserver(mObserver);
          }

        cursor.setNotificationUri(getContext().getContentResolver(), getContentUri());
        return cursor;
      }

    protected abstract Cursor getCursor();
    protected abstract Uri getContentUri();
  }

Syndrome