Implementing a basic content provider class

suggest change

1) Create a Contract Class

A contract class defines constants that help applications work with the content URIs, column names, intent actions, and other features of a content provider. Contract classes are not included automatically with a provider; the provider’s developer has to define them and then make them available to other developers.

A provider usually has a single authority, which serves as its Android-internal name. To avoid conflicts with other providers, use a unique content authority. Because this recommendation is also true for Android package names, you can define your provider authority as an extension of the name of the package containing the provider. For example, if your Android package name is com.example.appname, you should give your provider the authority com.example.appname.provider.

public class MyContract {

public static final String CONTENT_AUTHORITY = “com.example.myApp”; public static final String PATH_DATATABLE = “dataTable”; public static final String TABLE_NAME = “dataTable”;


A content URI is a URI that identifies data in a provider. Content URIs include the symbolic name of the entire provider (its authority) and a name that points to a table or file (a path). The optional id part points to an individual row in a table. Every data access method of ContentProvider has a content URI as an argument; this allows you to determine the table, row, or file to access. Define these in the contract class.

public static final Uri BASE_CONTENT_URI = Uri.parse("content://" + CONTENT_AUTHORITY);
public static final Uri CONTENT_URI = BASE_CONTENT_URI.buildUpon().appendPath(PATH_DATATABLE).build();

// define all columns of table and common functions required

2) Create the Helper Class

A helper class manages database creation and version management.

public class DatabaseHelper extends SQLiteOpenHelper {

// Increment the version when there is a change in the structure of database public static final int DATABASE_VERSION = 1; // The name of the database in the filesystem, you can choose this to be anything public static final String DATABASE_NAME = “weather.db”;

public DatabaseHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); }

@Override public void onCreate(SQLiteDatabase db) { // Called when the database is created for the first time. This is where the // creation of tables and the initial population of the tables should happen. }

@Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { // Called when the database needs to be upgraded. The implementation // should use this method to drop tables, add tables, or do anything else it // needs to upgrade to the new schema version. }


3) Create a class that extends ContentProvider class

public class MyProvider extends ContentProvider {

public DatabaseHelper dbHelper;

public static final UriMatcher matcher = buildUriMatcher();
public static final int DATA_TABLE = 100;
public static final int DATA_TABLE_DATE = 101;

A UriMatcher maps an authority and path to an integer value. The method match() returns a unique integer value for a URI (it can be any arbitrary number, as long as it’s unique). A switch statement chooses between querying the entire table, and querying for a single record. Our UriMatcher returns 100 if the URI is the Content URI of Table and 101 if the URI points to a specific row within that table. You can use the \# wildcard to match with any number and \* to match with any string.

public static UriMatcher buildUriMatcher() {

UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); uriMatcher.addURI(CONTENT_AUTHORITY, MyContract.PATH_DATATABLE, DATA_TABLE); uriMatcher.addURI(CONTENT_AUTHORITY, MyContract.PATH_DATATABLE + “/#”, DATA_TABLE_DATE); return uriMatcher;


IMPORTANT: the ordering of addURI() calls matters! The UriMatcher will look in sequential order from first added to last. Since wildcards like \# and \* are greedy, you will need to make sure that you have ordered your URIs correctly. For example:

uriMatcher.addURI(CONTENT_AUTHORITY, "/example", 1);
uriMatcher.addURI(CONTENT_AUTHORITY, "/*",       2);

is the proper ordering, since the matcher will look for /example first before resorting to the /* match. If these method calls were reversed and you called uriMatcher.match("/example"), then the UriMatcher will stop looking for matches once it encounters the /* path and return the wrong result!

You will then need to override these functions:

onCreate(): Initialize your provider. The Android system calls this method immediately after it creates your provider. Notice that your provider is not created until a ContentResolver object tries to access it.

public boolean onCreate() {

dbhelper = new DatabaseHelper(getContext()); return true;


getType(): Return the MIME type corresponding to a content URI

public String getType(Uri uri) {

final int match = matcher.match(uri); switch (match) { case DATA_TABLE: return ContentResolver.CURSOR_DIR_BASE_TYPE + “/” + MyContract.CONTENT_AUTHORITY + “/” + MyContract.PATH_DATATABLE; case DATA_TABLE_DATE: return ContentResolver.ANY_CURSOR_ITEM_TYPE + “/” + MyContract.CONTENT_AUTHORITY + “/” + MyContract.PATH_DATATABLE; default: throw new UnsupportedOperationException(“Unknown Uri: “ + uri);



query(): Retrieve data from your provider. Use the arguments to select the table to query, the rows and columns to return, and the sort order of the result. Return the data as a Cursor object.

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {

Cursor retCursor = dbHelper.getReadableDatabase().query( MyContract.TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder); retCursor.setNotificationUri(getContext().getContentResolver(), uri); return retCursor;


Insert a new row into your provider. Use the arguments to select the destination table and to get the column values to use. Return a content URI for the newly-inserted row.

public Uri insert(Uri uri, ContentValues values)

final SQLiteDatabase db = dbHelper.getWritableDatabase(); long id = db.insert(MyContract.TABLE_NAME, null, values); return ContentUris.withAppendedId(MyContract.CONTENT_URI, ID);


delete(): Delete rows from your provider. Use the arguments to select the table and the rows to delete. Return the number of rows deleted.

public int delete(Uri uri, String selection, String[] selectionArgs) {

SQLiteDatabase db = dbHelper.getWritableDatabase(); int rowsDeleted = db.delete(MyContract.TABLE_NAME, selection, selectionArgs); getContext().getContentResolver().notifyChange(uri, null); return rowsDeleted;


update(): Update existing rows in your provider. Use the arguments to select the table and rows to update and to get the new column values. Return the number of rows updated.

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {

SQLiteDatabase db = dbHelper.getWritableDatabase(); int rowsUpdated = db.update(MyContract.TABLE_NAME, values, selection, selectionArgs); getContext().getContentResolver().notifyChange(uri, null); return rowsUpdated;


4) Update manifest file


Feedback about page:

Optional: your email if you want me to get back to you:

Table Of Contents