Utilizzo di CursorLoader senza ContentProvider

La documentazione di Android SDK dice che il startManagingCursor()metodo è obsoleto:

Questo metodo è deprecato. Utilizza invece la nuova classe CursorLoader con LoaderManager; questo è disponibile anche su piattaforme precedenti tramite il pacchetto di compatibilità Android. Questo metodo consente all'attività di occuparsi della gestione del ciclo di vita del Cursore in base al ciclo di vita dell'attività. Cioè, quando l'attività viene interrotta chiamerà automaticamente disableate () sul Cursor specificato, e quando viene riavviato in seguito chiamerà requery () per te. Quando l'attività viene distrutta, tutti i cursori gestiti verranno chiusi automaticamente. Se stai prendendo di mira HONEYCOMB o versioni successive, considera invece di utilizzare LoaderManager, disponibile tramite getLoaderManager ()

Quindi vorrei usare CursorLoader. Ma come posso usarlo con custom CursorAdaptere senza ContentProvider, quando ho bisogno dell'URI nel costruttore di CursorLoader?

Ho scritto un semplice CursorLoader che non necessita di un provider di contenuti:

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;
    }
}

Ha solo bisogno della AsyncTaskLoaderclasse. O quello in Android 3.0 o versioni successive o quello fornito con il pacchetto di compatibilità.

Ho anche scritto unListLoader che è compatibile con LoadManagere viene utilizzato per recuperare una java.util.Listraccolta generica .

Scrivi il tuo caricatore che utilizza la tua classe di database invece di un fornitore di contenuti. Il modo più semplice è semplicemente prendere l'origine della CursorLoaderclasse dalla libreria di compatibilità e sostituire le query del provider con le query alla tua classe helper db.

SimpleCursorLoader è una soluzione semplice, tuttavia non supporta l'aggiornamento del caricatore quando i dati cambiano. CommonsWare ha una libreria loaderex che aggiunge un SQLiteCursorLoader e supporta la nuova query sulle modifiche ai dati.

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

Una terza opzione sarebbe semplicemente sovrascrivere 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;
    }
};

Ciò si occuperà anche di interrogare nuovamente il cursore quando il database cambia.

Unico avvertimento: dovrai definire un altro osservatore, poiché Google nella sua infinita saggezza ha deciso di rendere privato il loro pacchetto. Se metti la classe nello stesso pacchetto di quello originale (o di quello compatibile) puoi effettivamente usare l'osservatore originale. L'osservatore è un oggetto molto leggero e non viene utilizzato da nessun'altra parte, quindi questo non fa molta differenza.

La terza opzione proposta da Timo Ohr, insieme ai commenti di Yeung, forniscono la risposta più semplice (il rasoio di Occam). Di seguito è riportato un esempio di una classe completa che funziona per me. Ci sono due regole per usare questa classe.

1. Estendi questa classe astratta e implementa i metodi getCursor () e getContentUri ().

2. Ogni volta che il database sottostante cambia (ad esempio, dopo un inserimento o una cancellazione), assicurati di chiamare

   getContentResolver().notifyChange(myUri, null);

   dove myUri è lo stesso restituito dall'implementazione del metodo getContentUri ().

Ecco il codice per la classe che ho usato:

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();
  }