Initializes the DatabaseContentProvider

Increments the hold count on the database lock for this thread, waiting for it to be released if another thread is already holding the lock. If this thread didn't already hold the database lock then a database transaction will be started. The transaction will be committed or rolled back when the last releaseDbLock() for this thread is called.

Implement this to insert a set of new rows, or the default implementation will iterate over the values and call insert(Uri, ContentValues) on each of them. As a courtesy, call notifyChange() after inserting.

Checks if other threads are blocked on this lock. This is typically used when the db is locked to tell if other threads are waiting to acquire the db lock.

A request to delete one or more rows. The selection clause is applied when performing the deletion, allowing the operation to affect multiple rows in a directory. As a courtesy, call notifyDelete() after deleting. The implementation is responsible for parsing out a row ID at the end of the URI, if a specific row is being deleted. That is, the client would pass in content://contacts/people/22 and the implementation is responsible for parsing the record number (22) when creating a SQL statement.

Get a non-persistent instance of this content provider. This is intended for use by the sync system, and is only required to be implemented if isSyncable() returns true.

Implement this to insert a new row. As a courtesy, call notifyChange() after inserting.

Checks if the database lock is held by this thread.

Checks if the database is locked by another thread. This is just an estimate, since this status can change at any time, including after the call is made but before the result has been acted upon.

Merge diffs from a sync source with this content provider. This is intended for use by the sync system, and is only required to be implemented if isSyncable() returns true and this content provider is persistent.

Called when the provider is being started.

Invoked when the active sync has been canceled. The default implementation doesn't do anything (except ensure that this provider is syncable). Subclasses of ContentProvider that support canceling of sync should override this.

Receives a query request from a client in a local process, and returns a Cursor. This is called internally by the ContentResolver.

Example client call:

// Request a specific record.
 Cursor managedCursor = managedQuery(
                Contacts.People.CONTENT_URI.addId(2),
                projection,    // Which columns to return.
                null,          // WHERE clause.
                People.NAME + " ASC");   // Sort order.

Example implementation:

// SQLiteQueryBuilder is a helper class that creates the
        // proper SQL syntax for us.
        SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();

        // Set the table we're querying.
        qBuilder.setTables(DATABASE_TABLE_NAME);

        // If the query ends in a specific record number, we're
        // being asked for a specific record, so set the
        // WHERE clause in our query.
        if((URI_MATCHER.match(uri)) == SPECIFIC_MESSAGE){
            qBuilder.appendWhere("_id=" + uri.getPathLeafId());
        }

        // Make the query.
        Cursor c = qBuilder.query(mDb,
                projection,
                selection,
                selectionArgs,
                groupBy,
                having,
                sortOrder);
        c.setNotificationUri(getContext().getContentResolver(), uri);
        return c;

Decrement this thread's hold count on the database lock. If this will cause the thread to be released, then prior to decrementing the hold count the database transaction will be either committed if this and all previous calls to releaseDbLock for this lock were passed success=true or the transaction will be rolled back and a SQLException thrown.

Update a content URI. All rows matching the optionally provided selection will have their columns listed as the keys in the values map with the values of those keys. As a courtesy, call notifyChange() after updating.

Subclasses should override this instead of delete(). See delete() for details.

This method is called within a acquireDbLock()/releaseDbLock() block, which means a database transaction will be active during the call;

A helper method to delete all rows whose account is not in the accounts map. The accountColumnName is the name of the column that is expected to hold the account. If a row has an empty account it is never deleted.

make sure that there are no entries for accounts that no longer exist

An accessor for the DcpCursorFactory. This must be used by classes that extend DatabaseContentProvider when they open their real (not temporary) databases.

Each subclass of this class should define a subclass of AbstractTableMerger for each table they wish to merge. It should then override this method and return one instance of each merger, in sequence. Their merge methods will be called, one at a time, in the order supplied.

The default implementation returns an empty list, so that no merging will occur.

Subclasses should override this instead of insert(). See insert() for details.

This method is called within a acquireDbLock()/releaseDbLock() block, which means a database transaction will be active during the call;

Returns true if this instance is a temporary content provider.

Wraps a call to call() in a database acquire/release block. If an exception is caught during the call then the transaction will be marked as tainted, meaning it will be rolled back when the transaction is finally closed. This thread may already be running within a transaction, so this call to releaseDbLock(boolean) may not actually result in the transaction being closed.

If you don't require a return value, use lockAndRun(Runnable).

Wraps a call to run() in a database acquire/release block. If an exception is caught during the call then the transaction will be marked as tainted, meaning it will be rolled back when the transaction is finally closed. This thread may already be running within a transaction, so this call to releaseDbLock(boolean) may not actually result in the transaction being closed.

If you need to return a value value, use lockAndCall(Callable).

This is invoked at provider startup and when the set of active accounts changes.

Subclasses should override this instead of query(). See query() for details.

This method is *not* called within a acquireDbLock()/releaseDbLock() block for performance reasons. If an implementation needs atomic access to the database the lock can be acquired then.

Subclasses should override this instead of update(). See update() for details.

This method is called within a acquireDbLock()/releaseDbLock() block, which means a database transaction will be active during the call;