Android content provider example
Add the following in application tag in the manifest file, adjust the package name accordingly.
<activity android:name=".content_provider.views.ContentProviderActivity"
android:parentActivityName=".MainActivity"/>
<provider
android:authorities="com.example.androidcomponents"
android:name=".content_provider.data.VersionsProvider"
android:exported="false"
android:syncable="true"/>
activity_content_provider.xml, layout file for the content provider main screen
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools" android:id="@+id/fragment_container"
tools:layout="@layout/fragment_content_provider" android:layout_width="match_parent"
android:layout_height="match_parent" />
fragment_content_provider.xml, layout file for the content provider fragment
<?xml version="1.0" encoding="utf-8"?>
<ListView
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/lv_versions"
android:layout_width="match_parent"
android:layout_height="match_parent">
</ListView>
fragment_version_detail.xml, layout file for the version detail screen.
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<include layout="@layout/version_item"/>
<TextView
android:id="@+id/tv_uri"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
<TextView
android:id="@+id/tv_version_description"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
</LinearLayout>
version_item.xml, layout file for the version item in the list view.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<TextView
android:id="@+id/tv_version_name"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:gravity="center"
android:textStyle="bold"/>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="5"
android:gravity="right"
android:text="Version Code:"/>
<TextView
android:id="@+id/tv_version_code"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:paddingLeft="15dp"
android:layout_weight="5"/>
</LinearLayout>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
<TextView
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="5"
android:gravity="right"
android:text="Api Level:"/>
<TextView
android:id="@+id/tv_api_level"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:paddingLeft="15dp"
android:layout_weight="5"/>
</LinearLayout>
</LinearLayout>
Version.java, the model/pojo class for holding the Android version information.
public class Version {
private String versionName;
private String versionCode;
private String apiLevel;
private String description;
public Version(String name, String version, String apiLevel, String description){
this.versionName = name;
this.versionCode = version;
this.apiLevel = apiLevel;
this.description = description;
}
public String getVersionName() {
return versionName;
}
public String getVersionCode() {
return versionCode;
}
public String getApiLevel() {
return apiLevel;
}
public String getDescription() {
return description;
}
}
VersionsContract.java, the contract for database table and content provider.
public class VersionsContract {
public static final String CONTENT_AUTHORITY = "com.example.androidcomponents";
public static final Uri BASE_CONTENT_URI = Uri.parse("content://" + CONTENT_AUTHORITY);
public static final class VersionEntry implements BaseColumns {
// table name
public static final String TABLE_VERSIONS = "versions";
// columns
public static final String _ID = "_id";
public static final String COLUMN_DESCRIPTION = "description";
public static final String COLUMN_VERSION_NAME = "version_name";
public static final String COLUMN_VERSION_CODE = "version_code";
public static final String COLUMN_API_LEVEL = "api_level";
// content uri
public static final Uri CONTENT_URI = BASE_CONTENT_URI.buildUpon().appendPath(TABLE_VERSIONS).build();
// cursor of base type directory for multiple entries
public static final String CONTENT_DIR_TYPE = ContentResolver.CURSOR_DIR_BASE_TYPE + "/" + CONTENT_AUTHORITY + "/" + TABLE_VERSIONS;
// cursor of base type item for single entry
public static final String CONTENT_ITEM_TYPE = ContentResolver.CURSOR_ITEM_BASE_TYPE +"/" + CONTENT_AUTHORITY + "/" + TABLE_VERSIONS;
// insertion URIs
public static Uri buildVersionsUri(long id){
return ContentUris.withAppendedId(CONTENT_URI, id);
}
}
}
VersionsDBHelper.java, the sqlite database helper class.
public class VersionsDBHelper extends SQLiteOpenHelper {
public static final String LOG_TAG = VersionsDBHelper.class.getSimpleName();
private static final String DATABASE_NAME = "android_versions.db";
private static final int DATABASE_VERSION = 2;
public VersionsDBHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase sqLiteDatabase) {
final String SQL_CREATE_MOVIE_TABLE = "CREATE TABLE " +
VersionsContract.VersionEntry.TABLE_VERSIONS + "(" + VersionsContract.VersionEntry._ID +
" INTEGER PRIMARY KEY AUTOINCREMENT, " +
VersionsContract.VersionEntry.COLUMN_VERSION_NAME + " TEXT NOT NULL, " +
VersionsContract.VersionEntry.COLUMN_VERSION_CODE + " TEXT NOT NULL, " +
VersionsContract.VersionEntry.COLUMN_API_LEVEL + " TEXT NOT NULL, " +
VersionsContract.VersionEntry.COLUMN_DESCRIPTION + " TEXT NOT NULL);";
sqLiteDatabase.execSQL(SQL_CREATE_MOVIE_TABLE);
}
// Upgrade database when version is changed.
@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
Log.w(LOG_TAG, "Upgrading database from version " + oldVersion + " to " +
newVersion + ". OLD DATA WILL BE DESTROYED");
// Drop the table
sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + VersionsContract.VersionEntry.TABLE_VERSIONS);
sqLiteDatabase.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" +
VersionsContract.VersionEntry.TABLE_VERSIONS + "'");
// re-create database
onCreate(sqLiteDatabase);
}
}
VersionsProvider.java, finally the content provider class for providing the version information.
public class VersionsProvider extends ContentProvider {
private static final String LOG_TAG = VersionsProvider.class.getSimpleName();
private static final UriMatcher sUriMatcher = buildUriMatcher();
private VersionsDBHelper mOpenHelper;
// Codes for the UriMatcher
private static final int VERSION = 100;
private static final int VERSION_WITH_ID = 200;
private static UriMatcher buildUriMatcher() {
// Build a UriMatcher by adding a specific code to return based on a match
final UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH);
final String authority = VersionsContract.CONTENT_AUTHORITY;
// add a code for each type of URI you want
matcher.addURI(authority, VersionsContract.VersionEntry.TABLE_VERSIONS, VERSION);
matcher.addURI(authority, VersionsContract.VersionEntry.TABLE_VERSIONS + "/#", VERSION_WITH_ID);
return matcher;
}
@Override
public boolean onCreate() {
mOpenHelper = new VersionsDBHelper(getContext());
return true;
}
@Override
public String getType(Uri uri) {
final int match = sUriMatcher.match(uri);
switch (match) {
case VERSION: {
return VersionsContract.VersionEntry.CONTENT_DIR_TYPE;
}
case VERSION_WITH_ID: {
return VersionsContract.VersionEntry.CONTENT_ITEM_TYPE;
}
default: {
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
}
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
Cursor retCursor;
switch (sUriMatcher.match(uri)) {
// All versions selected
case VERSION: {
retCursor = mOpenHelper.getReadableDatabase().query(
VersionsContract.VersionEntry.TABLE_VERSIONS,
projection,
selection,
selectionArgs,
null,
null,
sortOrder);
return retCursor;
}
// Individual version based on Id selected
case VERSION_WITH_ID: {
retCursor = mOpenHelper.getReadableDatabase().query(
VersionsContract.VersionEntry.TABLE_VERSIONS,
projection,
VersionsContract.VersionEntry._ID + " = ?",
new String[]{String.valueOf(ContentUris.parseId(uri))},
null,
null,
sortOrder);
return retCursor;
}
default: {
// By default, we assume a bad URI
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
}
@Override
public Uri insert(Uri uri, ContentValues values) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
Uri returnUri;
switch (sUriMatcher.match(uri)) {
case VERSION: {
long _id = db.insert(VersionsContract.VersionEntry.TABLE_VERSIONS, null, values);
// insert unless it is already contained in the database
if (_id > 0) {
returnUri = VersionsContract.VersionEntry.buildVersionsUri(_id);
} else {
throw new android.database.SQLException("Failed to insert row into: " + uri);
}
break;
}
default: {
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
getContext().getContentResolver().notifyChange(uri, null);
return returnUri;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
int numDeleted;
switch (match) {
case VERSION:
numDeleted = db.delete(VersionsContract.VersionEntry.TABLE_VERSIONS, selection, selectionArgs);
// reset _ID
db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" +
VersionsContract.VersionEntry.TABLE_VERSIONS + "'");
break;
case VERSION_WITH_ID:
numDeleted = db.delete(VersionsContract.VersionEntry.TABLE_VERSIONS,
VersionsContract.VersionEntry._ID + " = ?",
new String[]{String.valueOf(ContentUris.parseId(uri))});
// reset _ID
db.execSQL("DELETE FROM SQLITE_SEQUENCE WHERE NAME = '" +
VersionsContract.VersionEntry.TABLE_VERSIONS + "'");
break;
default:
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
return numDeleted;
}
@Override
public int bulkInsert(Uri uri, ContentValues[] values) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
switch (match) {
case VERSION:
// allows for multiple transactions
db.beginTransaction();
// keep track of successful inserts
int numInserted = 0;
try {
for (ContentValues value : values) {
if (value == null) {
throw new IllegalArgumentException("Cannot have null content values");
}
long _id = -1;
try {
_id = db.insertOrThrow(VersionsContract.VersionEntry.TABLE_VERSIONS, null, value);
} catch (SQLiteConstraintException e) {
Log.w(LOG_TAG, e.toString());
}
if (_id != -1) {
numInserted++;
}
}
if (numInserted > 0) {
// If no errors, declare a successful transaction.
// database will not populate if this is not called
db.setTransactionSuccessful();
}
} finally {
// all transactions occur at once
db.endTransaction();
}
if (numInserted > 0) {
// if there was successful insertion, notify the content resolver that there was a change
getContext().getContentResolver().notifyChange(uri, null);
}
return numInserted;
default:
return super.bulkInsert(uri, values);
}
}
@Override
public int update(Uri uri, ContentValues contentValues, String selection, String[] selectionArgs) {
final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
int numUpdated = 0;
if (contentValues == null) {
throw new IllegalArgumentException("Cannot have null content values");
}
switch (sUriMatcher.match(uri)) {
case VERSION: {
numUpdated = db.update(VersionsContract.VersionEntry.TABLE_VERSIONS,
contentValues,
selection,
selectionArgs);
break;
}
case VERSION_WITH_ID: {
numUpdated = db.update(VersionsContract.VersionEntry.TABLE_VERSIONS,
contentValues,
VersionsContract.VersionEntry._ID + " = ?",
new String[]{String.valueOf(ContentUris.parseId(uri))});
break;
}
default: {
throw new UnsupportedOperationException("Unknown uri: " + uri);
}
}
if (numUpdated > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
return numUpdated;
}
}
ContentProviderActivity.java, the main activity for show casing the content provider example.
public class ContentProviderActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_content_provider);
getSupportFragmentManager().beginTransaction().replace(R.id.fragment_container,
new FragmentContentProvider()).commit();
}
}
FragmentContentProvider.java, the main fragment for show casing the content provider example.
public class FragmentContentProvider extends Fragment implements LoaderManager.LoaderCallbacks<Cursor>{
private static final String LOG_TAG = FragmentContentProvider.class.getSimpleName();
private VersionAdapter mVersionAdapter;
private ListView lvVersions;
private static final int CURSOR_LOADER_ID = 0;
Version[] versions = {
new Version("Cupcake", "1.5", "3", "The first release of Android"),
new Version("Donut", "1.6", "4", "The world's information is at your fingertips – search the web, get driving directions... or just watch cat videos."),
new Version("Eclair", "2.0-2.1", "5-7", "Make your home screen just how you want it. Arrange apps and widgets across multiple screens and in folders. Stunning live wallpapers " + "respond to your touch."),
new Version("Froyo", "2.2-2.2.3", "8", "Voice Typing lets you input text, and Voice Actions let you control your phone, just by speaking."),
new Version("GingerBread", "2.3-2.3.7", "9-10", "New sensors make Android great for gaming - so you can touch, tap, tilt, and play away."),
new Version("Honeycomb", "3.0-3.2.6", "11-13", "Optimized for tablets, this release opens up new horizons wherever you are."),
new Version("Ice Cream Sandwich", "4.0-4.0.4", "14-15", "Android comes of age with a new, refined design. Simple, beautiful and beyond smart."),
new Version("Jelly Bean", "4.1-4.3.1", "16-18", "Android is fast and smooth with buttery graphics. With Google Now, you get just the right information at the right time."),
new Version("KitKat", "4.4-4.4.4", "19-20", "Smart, simple, and truly yours. A more polished design, improved performance, and new features."),
new Version("Lollipop", "5.0-5.1.1", "21-22", "A sweet new take on Android. Get the smarts of Android on screens big and small – with the right information at the right moment."),
new Version("Marshmallow", "6.0–6.0.1", "23", "Now on Tap anticipates what you need in the moment. With a simple tap, you can get cards with useful information and apps that feed your need to know."),
new Version("Nougat", "7.0–7.1.2", "24–25", "With more ways to make Android your own, Android Nougat is our sweetest release yet.")
};
public FragmentContentProvider() {
}
@Override
public void onActivityCreated(Bundle savedInstanceState){
Cursor c =
getActivity().getContentResolver().query(VersionsContract.VersionEntry.CONTENT_URI,
new String[]{VersionsContract.VersionEntry._ID},
null,
null,
null);
if (c.getCount() == 0) {
insertData();
}
// initialize loader
getLoaderManager().initLoader(CURSOR_LOADER_ID, null, this);
super.onActivityCreated(savedInstanceState);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// inflate fragment_main layout
final View rootView = inflater.inflate(R.layout.fragment_content_provider, container, false);
// initialize our VersionAdapter
mVersionAdapter = new VersionAdapter(getActivity(), null, 0);
lvVersions = (ListView) rootView.findViewById(R.id.lv_versions);
lvVersions.setAdapter(mVersionAdapter);
lvVersions.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
// increment the position to match Database Ids indexed starting at 1
int uriId = position + 1;
Uri uri = ContentUris.withAppendedId(VersionsContract.VersionEntry.CONTENT_URI, uriId);
FragmentVersionDetail detailFragment = FragmentVersionDetail.newInstance(uriId, uri);
getActivity().getSupportFragmentManager().beginTransaction()
.replace(R.id.fragment_container, detailFragment)
.addToBackStack(null).commit();
}
});
return rootView;
}
// insert data into database
public void insertData(){
ContentValues[] versionValuesArr = new ContentValues[versions.length];
for(int i = 0; i < versions.length; i++){
versionValuesArr[i] = new ContentValues();
versionValuesArr[i].put(VersionsContract.VersionEntry.COLUMN_VERSION_NAME, versions[i].getVersionName());
versionValuesArr[i].put(VersionsContract.VersionEntry.COLUMN_VERSION_CODE, versions[i].getVersionCode());
versionValuesArr[i].put(VersionsContract.VersionEntry.COLUMN_API_LEVEL, versions[i].getApiLevel());
versionValuesArr[i].put(VersionsContract.VersionEntry.COLUMN_DESCRIPTION, versions[i].getDescription());
}
// bulkInsert our ContentValues array
getActivity().getContentResolver().bulkInsert(VersionsContract.VersionEntry.CONTENT_URI, versionValuesArr);
}
// Attach loader to our versions database query, run when loader is initialized
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args){
return new CursorLoader(getActivity(),
VersionsContract.VersionEntry.CONTENT_URI,
null,
null,
null,
null);
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState){
super.onViewCreated(view, savedInstanceState);
}
// Set the cursor in our CursorAdapter once the Cursor is loaded
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
mVersionAdapter.swapCursor(data);
}
// reset CursorAdapter on Loader Reset
@Override
public void onLoaderReset(Loader<Cursor> loader){
mVersionAdapter.swapCursor(null);
}
}
VersionAdapter.java, the adapter for showing the version as a list in the ListView.
public class VersionAdapter extends CursorAdapter {
public VersionAdapter(Context context, Cursor c, int flags) {
super(context, c, flags);
mContext = context;
}
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent){
int layoutId = R.layout.version_item;
View view = LayoutInflater.from(context).inflate(layoutId, parent, false);
ViewHolder viewHolder = new ViewHolder(view);
view.setTag(viewHolder);
return view;
}
@Override
public void bindView(View view, Context context, Cursor cursor){
ViewHolder viewHolder = (ViewHolder) view.getTag();
int versionNameIndex = cursor.getColumnIndex(VersionsContract.VersionEntry.COLUMN_VERSION_NAME);
int versionCodeIndex = cursor.getColumnIndex(VersionsContract.VersionEntry.COLUMN_VERSION_CODE);
int apiLevelIndex = cursor.getColumnIndex(VersionsContract.VersionEntry.COLUMN_API_LEVEL);
viewHolder.tvVersionName.setText(cursor.getString(versionNameIndex));
viewHolder.tvVersionCode.setText(cursor.getString(versionCodeIndex));
viewHolder.tvApiLevel.setText(cursor.getString(apiLevelIndex));
}
public static class ViewHolder {
public final TextView tvVersionName, tvVersionCode, tvApiLevel;
public ViewHolder(View view){
tvVersionName = (TextView) view.findViewById(R.id.tv_version_name);
tvVersionCode = (TextView) view.findViewById(R.id.tv_version_code);
tvApiLevel = (TextView) view.findViewById(R.id.tv_api_level);
}
}
}
FragmentVersionDetail.java, the fragment for showing a single version information.
public class FragmentVersionDetail extends Fragment implements LoaderManager.LoaderCallbacks<Cursor>{
private Cursor mDetailCursor;
private int mPosition;
private TextView tvVersionName, tvVersionCode, tvApiLevel, tvUri, tvVersionDescription;
private Uri mUri;
private static final int CURSOR_LOADER_ID = 0;
public static FragmentVersionDetail newInstance(int position, Uri uri) {
FragmentVersionDetail fragment = new FragmentVersionDetail();
Bundle args = new Bundle();
fragment.mPosition = position;
fragment.mUri = uri;
args.putInt("id", position);
fragment.setArguments(args);
return fragment;
}
public FragmentVersionDetail() {
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_version_detail, container, false);
tvVersionName = (TextView) rootView.findViewById(R.id.tv_version_name);
tvVersionCode = (TextView) rootView.findViewById(R.id.tv_version_code);
tvApiLevel = (TextView) rootView.findViewById(R.id.tv_api_level);
tvUri = (TextView) rootView.findViewById(R.id.tv_uri);
tvVersionDescription = (TextView) rootView.findViewById(R.id.tv_version_description);
Bundle args = this.getArguments();
getLoaderManager().initLoader(CURSOR_LOADER_ID, args, FragmentVersionDetail.this);
return rootView;
}
@Override
public void onDetach() {
super.onDetach();
}
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args){
String selection = null;
String[] selectionArgs = null;
if (args != null) {
selection = VersionsContract.VersionEntry._ID;
selectionArgs = new String[]{String.valueOf(mPosition)};
}
return new CursorLoader(getActivity(),
mUri,
null,
selection,
selectionArgs,
null);
}
@Override
public void onViewCreated(View view, Bundle savedInstanceState){
super.onViewCreated(view, savedInstanceState);
}
// Set the cursor in our CursorAdapter once the Cursor is loaded
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
mDetailCursor = data;
mDetailCursor.moveToFirst();
DatabaseUtils.dumpCursor(data);
tvVersionName.setText(mDetailCursor.getString(1));
tvVersionCode.setText(mDetailCursor.getString(2));
tvApiLevel.setText(mDetailCursor.getString(3));
tvVersionDescription.setText(mDetailCursor.getString(4));
tvUri.setText(mUri.toString());
}
// reset CursorAdapter on Loader Reset
@Override
public void onLoaderReset(Loader<Cursor> loader){
mDetailCursor = null;
}
}
Search within Codexpedia
Custom Search
Search the entire web
Custom Search
Related Posts