android - teclado - usar celular como mouse via usb

¿Para qué se utiliza el cursor.setNotificationUri()?

Question

Hice una investigación sobre cómo usar ContentProviders y Loaders en este tutorial

Cómo lo veo: tenemos una Activity con ListView , SimpleCursorAdapter y CursorLoader . También implementamos ContentProvider .

En una Activity podemos llamar a getContentResolver().insert(URI, contentValues); a través de un botón de clic.

En nuestra implementación de ContentProvider , al final del método insert() , llamamos getContentResolver().notifyChange(URI, null); y nuestro CursorLoader recibirá un mensaje de que debe recargar los datos y actualizar la interfaz de usuario. Además, si usamos FLAG_REGISTER_CONTENT_OBSERVER en SimpleCursorAdapter , también recibirá un mensaje y se onContentChanged() su método onContentChanged() .

Por lo tanto, nuestro ListView se actualizará si insertamos, actualizamos o eliminamos datos.

Activity.startManagingCursor(cursor); está en desuso, cursor.requery() desuso, por lo que no veo ningún sentido cursor.setNotificationUri() de cursor.setNotificationUri() .

Busqué en el código fuente del método setNotificationUri() y vi que llama a mContentResolver.registerContentObserver(mNotifyUri, true, mSelfObserver) dentro del método. También CursorLoader hace lo mismo. Finalmente el cursor recibirá un mensaje y se llamará al siguiente método dentro del Cursor:

protected void onChange(boolean selfChange) {
    synchronized (mSelfObserverLock) {
        mContentObservable.dispatchChange(selfChange, null);
        // ...
    }
}

Pero no puedo darle sentido a esto.

Entonces, mi pregunta es: ¿por qué deberíamos llamar cursor.setNotificationUri() en el método de query() de nuestra implementación ContentProvider ?

Answer 1

Si llama a Cursor.setNotificationUri() , el Cursor sabrá para qué ContentProvider Uri fue creado.

CursorLoader registra su propio ForceLoadContentObserver (que extiende ContentObserver ) con el ContentResolver de ContentResolver para el URI que especificó al llamar a setNotificationUri .

Entonces, una vez que ContentResolver sepa que el contenido de URI ha cambiado [esto sucede cuando llama a getContext().getContentResolver().notifyChange(uri, contentObserver); dentro de los métodos Insert insert() , update() y delete() ContentProvider , notifica a todos los observadores, incluido ForceLoadContentObserver de ForceLoadContentObserver .

ForceLoadContentObserver luego marca mContentChanged del cargador como verdadero

Answer 2

Yo uso un URI para el adaptador de cursor.

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

    Bundle args = new Bundle();
    Uri uri = TemperatureContract.SensorEntry.buildSensorID0AddressUri(mDeviceAddress);
    args.putParcelable("URI", uri);
    getSupportLoaderManager().initLoader(0, args, this);

}

@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
    if (args != null) {
        Uri mUri = args.getParcelable("URI");
        return new CursorLoader(this,
                mUri,
                null, // projection
                null, // selection
                null, // selectionArgs
                null); // sortOrder
    } else {
        return null;
    }
}

En otra clase, uso un URI diferente para cambiar el contenido de la base de datos . Para actualizar mi vista, tuve que cambiar la implementación predeterminada del método de update del proveedor de datos. La implementación predeterminada solo notifica el mismo URI. Tengo que notificar a otro URI.

Terminé llamando a la notifyChange() dos veces en mi clase de proveedor de datos, en el método de update :

@Override
public int update(
        Uri uri, ContentValues values, String selection, String[] selectionArgs) {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    final int match = sUriMatcher.match(uri);
    int rowsUpdated;
    switch (match) {
        case ...:
            break;
        case SENSOR_BY_ID_AND_ADDRESS:
            String sensorId = TemperatureContract.SensorEntry.getSensorIdFromUri(uri);
            String sensorAddress = TemperatureContract.SensorEntry.getSensorAddressFromUri(uri);
            rowsUpdated = db.update(
                    TemperatureContract.SensorEntry.TABLE_NAME, values, "sensorid = ? AND address = ?", new String[]{sensorId, sensorAddress});
            if (rowsUpdated != 0) {
                Uri otheruri = TemperatureContract.SensorEntry.buildSensorID0AddressUri(sensorAddress);
                getContext().getContentResolver().notifyChange(otheruri, null);
            }
            break;
        case ...:
            break;
        default:
            throw new UnsupportedOperationException("Unknown uri: " + uri);
    }
    if (rowsUpdated != 0) {
        getContext().getContentResolver().notifyChange(uri, null);
    }
    return rowsUpdated;

Hice lo mismo para los métodos de insert y delete .

Answer 3

CursorLoader registra el observador para el cursor, no para el URI.

Mire el código fuente de CursorLoader a continuación. Observe que CursorLoader registra contentObserver en el cursor .

/* Runs on a worker thread */
    @Override
    public Cursor loadInBackground() {
        synchronized (this) {
            if (isLoadInBackgroundCanceled()) {
                throw new OperationCanceledException();
            }
            mCancellationSignal = new CancellationSignal();
        }
        try {
            Cursor cursor = getContext().getContentResolver().query(mUri, mProjection, mSelection,
                    mSelectionArgs, mSortOrder, mCancellationSignal);
            if (cursor != null) {
                try {
                    // Ensure the cursor window is filled.
                    cursor.getCount();
                    cursor.registerContentObserver(mObserver);
                } catch (RuntimeException ex) {
                    cursor.close();
                    throw ex;
                }
            }
            return cursor;
        } finally {
            synchronized (this) {
                mCancellationSignal = null;
            }
        }

El Cursor debe llamar al método setNotificationUri() para registrar mSelfObserver en el uri .

//AbstractCursor.java
public void setNotificationUri(ContentResolver cr, Uri notifyUri, int userHandle) {
        synchronized (mSelfObserverLock) {
            mNotifyUri = notifyUri;
            mContentResolver = cr;
            if (mSelfObserver != null) {
                mContentResolver.unregisterContentObserver(mSelfObserver);
            }
            mSelfObserver = new SelfContentObserver(this);
            mContentResolver.registerContentObserver(mNotifyUri, true, mSelfObserver, userHandle); // register observer to the uri
            mSelfObserverRegistered = true;
        }
    }

Dentro de los métodos de insert , update y delete getContext().getContentResolver().notifyChange(uri, null); , debe llamar a getContext().getContentResolver().notifyChange(uri, null); Para notificar cambios a los observadores uri .

Entonces, si no llama al cursor#setNotificationUri() , su CursorLoader no recibirá una notificación si los datos subyacentes a esa uri cambian.