Content Provider, criando um

 Content Provider é uma interface genérica para acesso a dados no ambiente Android. Somente através do Content Provider é possível compartilhar dados entre aplicações. O acesso a um Content Provider é padronizado, e como sempre, acessar um Content Provider nativo ou um definido por você segue o mesmo formato, sem distinção.
 Acessamos um Content Provider por intermédio da classe cliente ContentResolver.

 Nesse teste, vamos implementar um Content Provider usando o SQLite como repositório de dados. Vamos fazer um Content Provider de localizações geográficas.
 O exemplo é baseado no sample NotePad. Então, toda semelhança não é mera coincidência!

 Como pretendemos acessar o Content Provider em múltiplas threads, estamos testando também o uso de uma trava de leitura-escrita para tornar os métodos de acesso ao Content Provider seguros em relação às threads.
 Devido ao fato de que esse banco de dados pode ficar muito grande, também implementaremos uma forma de acessar os dados usando a clausula "limit" do SQL.

 Vamos seguir os seguintes passos para criar nosso Content Provider:

 1. Criar uma classe contrato. Essa é uma classe com as constantes do Content Provider, como URIs, MIME types, nome das colunas da tabela, etc. Esta classe estabelece o contrato entre o Content Provider e as aplicações clientes.
 MyLocation.class package br.agorandroid.mylocationprovider; import android.content.ContentUris; import android.net.Uri; import android.provider.BaseColumns; /** * @author A H Gusukuma * * agorandroid.blogspot.com */ public final class MyLocation { public static final String AUTHORITY = "br.com.agorandroid.mylocation.provider"; // This class cannot be instantiated private MyLocation() { } /** * Location table contract */ public static final class Locations implements BaseColumns { // This class cannot be instantiated private Locations() {} /** * The table name offered by this provider */ public static final String TABLE_NAME = "locations"; /* * URI definitions */ /** * The scheme part for this provider's URI */ private static final String SCHEME = "content://"; /** * Path parts for the URIs */ /** * Path part for the Locations URI */ private static final String PATH_LOCATIONS = "/locations"; /** * Path part for the Location ID URI */ private static final String PATH_LOCATION_ID = "/locations/"; /** * 0-relative position of a Location ID segment in the path part of a location ID URI */ public static final int LOCATION_ID_PATH_POSITION = 1; /** * Limit query parameter key */ public static final String LIMIT_PARAMETER_KEY = "limit"; /** * The content:// style URL for this table */ public static final Uri CONTENT_URI = Uri.parse(SCHEME + AUTHORITY + PATH_LOCATIONS); /** * The content URI base for a single location. Callers must * append a numeric location id to this Uri to retrieve a location */ public static final Uri CONTENT_ID_URI_BASE = Uri.parse(SCHEME + AUTHORITY + PATH_LOCATION_ID); /** * The content URI match pattern for a single location, specified by its ID. Use this to match * incoming URIs or to construct an Intent. */ public static final Uri CONTENT_ID_URI_PATTERN = Uri.parse(SCHEME + AUTHORITY + PATH_LOCATION_ID + "/#"); /* * MIME type definitions */ /** * The MIME type of {@link #CONTENT_URI} providing a directory of locations. */ public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.br.com.agorandroid.provider.locations"; /** * The MIME type of a {@link #CONTENT_URI} sub-directory of a single * location. */ public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/vnd.br.com.agorandroid.provider.locations"; /* * Column definitions */ /** * Column name for the provider of the location * <p> Type: TEXT (String from location.getProvider())</P> */ public static final String COLUMN_NAME_PROVIDER = "provider"; /** * Column name for the time * <p> Type: INTEGER (long from location.getTime())</P> */ public static final String COLUMN_NAME_TIME = "time"; /** * Column name for the accuracy * <p> Type: FLOAT (float from location.getAccuracy())</P> */ public static final String COLUMN_NAME_ACCURACY = "accuracy"; /** * Column name for the latitude * <p> Type: FLOAT (double from location.getLatitude())</P> */ public static final String COLUMN_NAME_LATITUDE = "latitude"; /** * Column name for the longitude * <p> Type: FLOAT (double from location.getLongitude())</P> */ public static final String COLUMN_NAME_LONGITUDE = "longitude"; /** * The default sort order for this table */ public static final String DEFAULT_SORT_ORDER = COLUMN_NAME_TIME + " DESC"; /** * make Uri + id */ public static Uri getUriItemId(long id) { Uri mUri = ContentUris.withAppendedId(CONTENT_URI, id); return mUri; } } }

 2. Definição da base de dados
  Vamos extender a classe SQLiteOpenHelper e implementar os métodos onCreate e onUpgrade.

 3. Criando o Content Provider
  Além de implementar os métodos onCreate, query, insert, delete, update e getType vamos definir também uma instância da classe utilitária UriMatcher. O UriMatcher nos ajudará a manipular as URIs para identificar qual formato estamos tratando.
 Também vamos instanciar um trava ReentrantReadWriteLock. 

 Vejamos o código:

 MyLocationProvider.class /** * */ package br.agorandroid.mylocationprovider; import java.util.HashMap; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; import android.content.ContentProvider; import android.content.ContentValues; import android.content.Context; import android.content.UriMatcher; import android.database.Cursor; import android.database.SQLException; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.database.sqlite.SQLiteQueryBuilder; import android.net.Uri; import android.text.TextUtils; import android.util.Log; /** * @author A H Gusukuma * * agorandroid.blogspot.com */ public class MyLocationProvider extends ContentProvider { // Used for debugging and logging private static final String TAG = "MyLocationProvider"; /** * The database that the provider uses as its underlying data store */ private static final String DATABASE_NAME = "mylocation.db"; /** * The database version */ private static final int DATABASE_VERSION = 1; /** * A projection map used to select columns from the database */ private static HashMap<String, String> sLocationsProjectionMap; /** * Standard projection for the interesting columns of a normal note. */ private static final String[] READ_LOCATION_PROJECTION = new String[] { MyLocation.Locations._ID, // Projection position 0, the Location id MyLocation.Locations.COLUMN_NAME_PROVIDER, // Projection position 1, the Location provider MyLocation.Locations.COLUMN_NAME_TIME, // Projection position 2, the Location time MyLocation.Locations.COLUMN_NAME_ACCURACY, // Projection position 3, the Location accuracy MyLocation.Locations.COLUMN_NAME_LATITUDE, // Projection position 4, the Location latitude MyLocation.Locations.COLUMN_NAME_LONGITUDE // Projection position 5, the Location longitude }; private static final int READ_LOCATION_PROVIDER = 1; private static final int READ_LOCATION_TIME = 2; private static final int READ_LOCATION_ACCURACY = 3; private static final int READ_LOCATION_LATITUDE = 4; private static final int READ_LOCATION_LONGITUDE = 5; /* * Constants used by the Uri matcher to choose an action based on the pattern * of the incoming URI */ // The incoming URI matches the Locations URI pattern private static final int LOCATIONS = 1; // The incoming URI matches the Locations URI pattern with Limit private static final int LOCATIONS_LIMITED = 2; // The incoming URI matches the Location ID URI pattern private static final int LOCATION_ID = 3; /** * A UriMatcher instance */ private static final UriMatcher sUriMatcher; // Handle to a new DatabaseHelper. private DatabaseHelper mOpenHelper; // ReadWriteLock to control concurrent access to db private final ReadWriteLock mLock = new ReentrantReadWriteLock(); private final Lock rLock = mLock.readLock(); private final Lock wLock = mLock.writeLock(); /** * A block that instantiates and sets static objects */ static { /* * Creates and initializes the URI matcher */ // Create a new instance sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH); // Add a pattern that routes URIs terminated with "locations" to a LOCATIONS operation sUriMatcher.addURI(MyLocation.AUTHORITY, MyLocation.Locations.TABLE_NAME, LOCATIONS); // Add a pattern that routes URIs terminated with "locations/limit" to a LOCATIONS operation with Limit sUriMatcher.addURI(MyLocation.AUTHORITY, MyLocation.Locations.TABLE_NAME + "/" + MyLocation.Locations.LIMIT_PARAMETER_KEY + "*", LOCATIONS_LIMITED); // Add a pattern that routes URIs terminated with "locations" plus an integer // to a location ID operation sUriMatcher.addURI(MyLocation.AUTHORITY, MyLocation.Locations.TABLE_NAME + "/#", LOCATION_ID); /* * Creates and initializes a projection map that returns all columns */ // Creates a new projection map instance. The map returns a column name // given a string. The two are usually equal. sLocationsProjectionMap = new HashMap<String, String>(); // Maps the string "_ID" to the column name "_ID" sLocationsProjectionMap.put(MyLocation.Locations._ID, MyLocation.Locations._ID); // Maps "title" to "title" sLocationsProjectionMap.put( MyLocation.Locations.COLUMN_NAME_PROVIDER, MyLocation.Locations.COLUMN_NAME_PROVIDER); // Maps "note" to "note" sLocationsProjectionMap.put(MyLocation.Locations.COLUMN_NAME_TIME, MyLocation.Locations.COLUMN_NAME_TIME); // Maps "created" to "created" sLocationsProjectionMap.put(MyLocation.Locations.COLUMN_NAME_ACCURACY, MyLocation.Locations.COLUMN_NAME_ACCURACY); // Maps "modified" to "modified" sLocationsProjectionMap.put( MyLocation.Locations.COLUMN_NAME_LATITUDE, MyLocation.Locations.COLUMN_NAME_LATITUDE); // Maps "modified" to "modified" sLocationsProjectionMap.put( MyLocation.Locations.COLUMN_NAME_LONGITUDE, MyLocation.Locations.COLUMN_NAME_LONGITUDE); } /** * * This class helps open, create, and upgrade the database file. */ static class DatabaseHelper extends SQLiteOpenHelper { DatabaseHelper(Context context) { // calls the super constructor, requesting the default cursor factory. super(context, DATABASE_NAME, null, DATABASE_VERSION); } /** * * Creates the underlying database with table name and column names taken from the * MyLocation class. */ @Override public void onCreate(SQLiteDatabase db) { db.execSQL("CREATE TABLE " + MyLocation.Locations.TABLE_NAME + " (" + MyLocation.Locations._ID + " INTEGER PRIMARY KEY," + MyLocation.Locations.COLUMN_NAME_PROVIDER + " TEXT," + MyLocation.Locations.COLUMN_NAME_TIME + " INTEGER," + MyLocation.Locations.COLUMN_NAME_ACCURACY + " FLOAT," + MyLocation.Locations.COLUMN_NAME_LATITUDE + " FLOAT," + MyLocation.Locations.COLUMN_NAME_LONGITUDE + " FLOAT" + ");"); } /** * * Demonstrates that the provider must consider what happens when the * underlying datastore is changed. In this sample, the database is upgraded the database * by destroying the existing data. * A real application should upgrade the database in place. */ @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // Logs that the database is being upgraded Log.w(TAG, "Upgrading database from version " + oldVersion + " to " + newVersion + ", which will destroy all old data"); // Kills the table and existing data db.execSQL("DROP TABLE IF EXISTS " + MyLocation.Locations.TABLE_NAME); // Recreates the database with a new version onCreate(db); } } /** * * Initializes the provider by creating a new DatabaseHelper. onCreate() is called * automatically when Android creates the provider in response to a resolver request from a * client. */ @Override public boolean onCreate() { // Creates a new helper object. Note that the database itself isn't opened until // something tries to access it, and it's only created if it doesn't already exist. mOpenHelper = new DatabaseHelper(getContext()); // Assumes that any failures will be reported by a thrown exception. return true; } @Override public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { rLock.lock(); try { // Constructs a new query builder and sets its table name SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); qb.setTables(MyLocation.Locations.TABLE_NAME); String sLimit = null; /** * Choose the projection and adjust the "where" clause based on URI pattern-matching. */ switch (sUriMatcher.match(uri)) { /* If the incoming URI is for a single location identified by its ID, chooses the * location ID projection, and appends "_ID = <locationid>" to the where clause, so that * it selects that single location */ case LOCATION_ID: qb.setProjectionMap(sLocationsProjectionMap); qb.appendWhere( MyLocation.Locations._ID + // the name of the ID column "=" + // the position of the location ID itself in the incoming URI uri.getPathSegments().get(MyLocation.Locations.LOCATION_ID_PATH_POSITION)); break; // If the incoming URI is for locations with or without limit , chooses the Locations projection case LOCATIONS: case LOCATIONS_LIMITED: qb.setProjectionMap(sLocationsProjectionMap); sLimit = uri.getQueryParameter(MyLocation.Locations.LIMIT_PARAMETER_KEY); break; default: // If the URI doesn't match any of the known patterns, throw an exception. throw new IllegalArgumentException("Unknown URI " + uri); } String orderBy; // If no sort order is specified, uses the default if (TextUtils.isEmpty(sortOrder)) { orderBy = MyLocation.Locations.DEFAULT_SORT_ORDER; } else { // otherwise, uses the incoming sort order orderBy = sortOrder; } // Opens the database object in "read" mode, since no writes need to be done. SQLiteDatabase db = mOpenHelper.getReadableDatabase(); /* * Performs the query. If no problems occur trying to read the database, then a Cursor * object is returned; otherwise, the cursor variable contains null. If no records were * selected, then the Cursor object is empty, and Cursor.getCount() returns 0. */ Cursor c = qb.query( db, // The database to query projection, // The columns to return from the query selection, // The columns for the where clause selectionArgs, // The values for the where clause null, // don't group the rows null, // don't filter by row groups orderBy, // The sort order sLimit // The limit ); // Tells the Cursor what URI to watch, so it knows when its source data changes c.setNotificationUri(getContext().getContentResolver(), uri); return c; } finally { rLock.unlock(); } } @Override public Uri insert(Uri uri, ContentValues initialValues) { wLock.lock(); try { // Validates the incoming URI. Only the full provider URI is allowed for inserts. if (sUriMatcher.match(uri) != LOCATIONS) { throw new IllegalArgumentException("Unknown URI " + uri); } // A map to hold the new record's values. ContentValues values; // If the incoming values map is not null, uses it for the new values. if (initialValues != null) { values = new ContentValues(initialValues); } else { // Otherwise, create a new value map throw new IllegalArgumentException("Empty values"); } // Opens the database object in "write" mode. SQLiteDatabase db = mOpenHelper.getWritableDatabase(); // Performs the insert and returns the ID of the new location. long rowId = db.insert( MyLocation.Locations.TABLE_NAME, // The table to insert into. MyLocation.Locations.COLUMN_NAME_PROVIDER, // A hack, SQLite sets this column value to null // if values is empty. values // A map of column names, and the values to insert // into the columns. ); // If the insert succeeded, the row ID exists. if (rowId > 0) { // Creates a URI with the note ID pattern and the new row ID appended to it. Uri noteUri = MyLocation.Locations.getUriItemId(rowId); // Notifies observers registered against this provider that the data changed. getContext().getContentResolver().notifyChange(noteUri, null); return noteUri; } // If the insert didn't succeed, then the rowID is <= 0. Throws an exception. throw new SQLException("Failed to insert row into " + uri); } finally { wLock.unlock(); } } @Override public int delete(Uri uri, String where, String[] whereArgs) { wLock.lock(); int count; try { // Opens the database object in "write" mode. SQLiteDatabase db = mOpenHelper.getWritableDatabase(); String finalWhere; // Does the delete based on the incoming URI pattern. switch (sUriMatcher.match(uri)) { // If the incoming pattern matches the general pattern for locations, does a delete // based on the incoming "where" columns and arguments. case LOCATIONS: count = db.delete( MyLocation.Locations.TABLE_NAME, // The database table name where, // The incoming where clause column names whereArgs // The incoming where clause values ); break; // If the incoming URI matches a single location ID, does the delete based on the // incoming data, but modifies the where clause to restrict it to the // particular location ID. case LOCATION_ID: /* * Starts a final WHERE clause by restricting it to the * desired location ID. */ finalWhere = MyLocation.Locations._ID + // The ID column name " = " + // test for equality uri.getPathSegments(). // the incoming note ID get(MyLocation.Locations.LOCATION_ID_PATH_POSITION) ; // If there were additional selection criteria, append them to the final // WHERE clause if (where != null) { finalWhere = finalWhere + " AND " + where; } // Performs the delete. count = db.delete( MyLocation.Locations.TABLE_NAME, // The database table name. finalWhere, // The final WHERE clause whereArgs // The incoming where clause values. ); break; // If the incoming pattern is invalid, throws an exception. default: throw new IllegalArgumentException("Unknown URI " + uri); } /*Gets a handle to the content resolver object for the current context, and notifies it * that the incoming URI changed. The object passes this along to the resolver framework, * and observers that have registered themselves for the provider are notified. */ getContext().getContentResolver().notifyChange(uri, null); // Returns the number of rows deleted. return count; } finally { wLock.unlock(); } } @Override public int update(Uri uri, ContentValues values, String where, String[] whereArgs) { wLock.lock(); try { // Opens the database object in "write" mode. SQLiteDatabase db = mOpenHelper.getWritableDatabase(); int count; String finalWhere; // Does the update based on the incoming URI pattern switch (sUriMatcher.match(uri)) { // If the incoming URI matches the general notes pattern, does the update based on // the incoming data. case LOCATIONS: // Does the update and returns the number of rows updated. count = db.update( MyLocation.Locations.TABLE_NAME, // The database table name. values, // A map of column names and new values to use. where, // The where clause column names. whereArgs // The where clause column values to select on. ); break; // If the incoming URI matches a single location ID, does the update based on the incoming // data, but modifies the where clause to restrict it to the particular location ID. case LOCATION_ID: /* * Starts creating the final WHERE clause by restricting it to the incoming * location ID. */ finalWhere = MyLocation.Locations._ID + // The ID column name " = " + // test for equality uri.getPathSegments(). // the incoming location ID get(MyLocation.Locations.LOCATION_ID_PATH_POSITION) ; // If there were additional selection criteria, append them to the final WHERE // clause if (where !=null) { finalWhere = finalWhere + " AND " + where; } // Does the update and returns the number of rows updated. count = db.update( MyLocation.Locations.TABLE_NAME, // The database table name. values, // A map of column names and new values to use. finalWhere, // The final WHERE clause to use // placeholders for whereArgs whereArgs // The where clause column values to select on, or // null if the values are in the where argument. ); break; // If the incoming pattern is invalid, throws an exception. default: throw new IllegalArgumentException("Unknown URI " + uri); } /*Gets a handle to the content resolver object for the current context, and notifies it * that the incoming URI changed. The object passes this along to the resolver framework, * and observers that have registered themselves for the provider are notified. */ getContext().getContentResolver().notifyChange(uri, null); // Returns the number of rows updated. return count; } finally { wLock.unlock(); } } @Override public String getType(Uri uri) { /** * Chooses the MIME type based on the incoming URI pattern */ switch (sUriMatcher.match(uri)) { // If the pattern is for locations, returns the general content type. case LOCATIONS: return MyLocation.Locations.CONTENT_TYPE; // If the pattern is for location IDs, returns the location ID content type. case LOCATION_ID: return MyLocation.Locations.CONTENT_ITEM_TYPE; // If the URI pattern doesn't match any permitted patterns, throws an exception. default: throw new IllegalArgumentException("Unknown URI " + uri); } } }

 4. Registrar o Content Provider no Manifest file.

<provider android:exported="false" android:authorities="br.com.agorandroid.mylocation.provider" android:name="MyLocationProvider"> <grant-uri-permission android:pathPattern=".*"/> </provider>

Com a opção android:exported="false" estamos informando que esse Content Provider é privado à aplicação.

 Pronto!
 Estamos com o Content Provider criado, no próximo post veremos como usá-lo.

 Abraços!