| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.example.android.notepad; |
| |
| import com.example.android.notepad.NotePad; |
| |
| import android.content.ClipDescription; |
| import android.content.ContentProvider; |
| import android.content.ContentUris; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.UriMatcher; |
| import android.content.ContentProvider.PipeDataWriter; |
| import android.content.res.AssetFileDescriptor; |
| import android.content.res.Resources; |
| 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.os.Bundle; |
| import android.os.ParcelFileDescriptor; |
| import android.provider.LiveFolders; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintWriter; |
| import java.io.UnsupportedEncodingException; |
| import java.util.HashMap; |
| |
| /** |
| * Provides access to a database of notes. Each note has a title, the note |
| * itself, a creation date and a modified data. |
| */ |
| public class NotePadProvider extends ContentProvider implements PipeDataWriter<Cursor> { |
| // Used for debugging and logging |
| private static final String TAG = "NotePadProvider"; |
| |
| /** |
| * The database that the provider uses as its underlying data store |
| */ |
| private static final String DATABASE_NAME = "note_pad.db"; |
| |
| /** |
| * The database version |
| */ |
| private static final int DATABASE_VERSION = 2; |
| |
| /** |
| * A projection map used to select columns from the database |
| */ |
| private static HashMap<String, String> sNotesProjectionMap; |
| |
| /** |
| * A projection map used to select columns from the database |
| */ |
| private static HashMap<String, String> sLiveFolderProjectionMap; |
| |
| /** |
| * Standard projection for the interesting columns of a normal note. |
| */ |
| private static final String[] READ_NOTE_PROJECTION = new String[] { |
| NotePad.Notes._ID, // Projection position 0, the note's id |
| NotePad.Notes.COLUMN_NAME_NOTE, // Projection position 1, the note's content |
| NotePad.Notes.COLUMN_NAME_TITLE, // Projection position 2, the note's title |
| }; |
| private static final int READ_NOTE_NOTE_INDEX = 1; |
| private static final int READ_NOTE_TITLE_INDEX = 2; |
| |
| /* |
| * Constants used by the Uri matcher to choose an action based on the pattern |
| * of the incoming URI |
| */ |
| // The incoming URI matches the Notes URI pattern |
| private static final int NOTES = 1; |
| |
| // The incoming URI matches the Note ID URI pattern |
| private static final int NOTE_ID = 2; |
| |
| // The incoming URI matches the Live Folder URI pattern |
| private static final int LIVE_FOLDER_NOTES = 3; |
| |
| /** |
| * A UriMatcher instance |
| */ |
| private static final UriMatcher sUriMatcher; |
| |
| // Handle to a new DatabaseHelper. |
| private DatabaseHelper mOpenHelper; |
| |
| |
| /** |
| * 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 "notes" to a NOTES operation |
| sUriMatcher.addURI(NotePad.AUTHORITY, "notes", NOTES); |
| |
| // Add a pattern that routes URIs terminated with "notes" plus an integer |
| // to a note ID operation |
| sUriMatcher.addURI(NotePad.AUTHORITY, "notes/#", NOTE_ID); |
| |
| // Add a pattern that routes URIs terminated with live_folders/notes to a |
| // live folder operation |
| sUriMatcher.addURI(NotePad.AUTHORITY, "live_folders/notes", LIVE_FOLDER_NOTES); |
| |
| /* |
| * 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. |
| sNotesProjectionMap = new HashMap<String, String>(); |
| |
| // Maps the string "_ID" to the column name "_ID" |
| sNotesProjectionMap.put(NotePad.Notes._ID, NotePad.Notes._ID); |
| |
| // Maps "title" to "title" |
| sNotesProjectionMap.put(NotePad.Notes.COLUMN_NAME_TITLE, NotePad.Notes.COLUMN_NAME_TITLE); |
| |
| // Maps "note" to "note" |
| sNotesProjectionMap.put(NotePad.Notes.COLUMN_NAME_NOTE, NotePad.Notes.COLUMN_NAME_NOTE); |
| |
| // Maps "created" to "created" |
| sNotesProjectionMap.put(NotePad.Notes.COLUMN_NAME_CREATE_DATE, |
| NotePad.Notes.COLUMN_NAME_CREATE_DATE); |
| |
| // Maps "modified" to "modified" |
| sNotesProjectionMap.put( |
| NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE, |
| NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE); |
| |
| /* |
| * Creates an initializes a projection map for handling Live Folders |
| */ |
| |
| // Creates a new projection map instance |
| sLiveFolderProjectionMap = new HashMap<String, String>(); |
| |
| // Maps "_ID" to "_ID AS _ID" for a live folder |
| sLiveFolderProjectionMap.put(LiveFolders._ID, NotePad.Notes._ID + " AS " + LiveFolders._ID); |
| |
| // Maps "NAME" to "title AS NAME" |
| sLiveFolderProjectionMap.put(LiveFolders.NAME, NotePad.Notes.COLUMN_NAME_TITLE + " AS " + |
| LiveFolders.NAME); |
| } |
| |
| /** |
| * |
| * This class helps open, create, and upgrade the database file. Set to package visibility |
| * for testing purposes. |
| */ |
| 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 |
| * NotePad class. |
| */ |
| @Override |
| public void onCreate(SQLiteDatabase db) { |
| db.execSQL("CREATE TABLE " + NotePad.Notes.TABLE_NAME + " (" |
| + NotePad.Notes._ID + " INTEGER PRIMARY KEY," |
| + NotePad.Notes.COLUMN_NAME_TITLE + " TEXT," |
| + NotePad.Notes.COLUMN_NAME_NOTE + " TEXT," |
| + NotePad.Notes.COLUMN_NAME_CREATE_DATE + " INTEGER," |
| + NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE + " INTEGER" |
| + ");"); |
| } |
| |
| /** |
| * |
| * 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 notes"); |
| |
| // 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; |
| } |
| |
| /** |
| * This method is called when a client calls |
| * {@link android.content.ContentResolver#query(Uri, String[], String, String[], String)}. |
| * Queries the database and returns a cursor containing the results. |
| * |
| * @return A cursor containing the results of the query. The cursor exists but is empty if |
| * the query returns no results or an exception occurs. |
| * @throws IllegalArgumentException if the incoming URI pattern is invalid. |
| */ |
| @Override |
| public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, |
| String sortOrder) { |
| |
| // Constructs a new query builder and sets its table name |
| SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); |
| qb.setTables(NotePad.Notes.TABLE_NAME); |
| |
| /** |
| * Choose the projection and adjust the "where" clause based on URI pattern-matching. |
| */ |
| switch (sUriMatcher.match(uri)) { |
| // If the incoming URI is for notes, chooses the Notes projection |
| case NOTES: |
| qb.setProjectionMap(sNotesProjectionMap); |
| break; |
| |
| /* If the incoming URI is for a single note identified by its ID, chooses the |
| * note ID projection, and appends "_ID = <noteID>" to the where clause, so that |
| * it selects that single note |
| */ |
| case NOTE_ID: |
| qb.setProjectionMap(sNotesProjectionMap); |
| qb.appendWhere( |
| NotePad.Notes._ID + // the name of the ID column |
| "=" + |
| // the position of the note ID itself in the incoming URI |
| uri.getPathSegments().get(NotePad.Notes.NOTE_ID_PATH_POSITION)); |
| break; |
| |
| case LIVE_FOLDER_NOTES: |
| // If the incoming URI is from a live folder, chooses the live folder projection. |
| qb.setProjectionMap(sLiveFolderProjectionMap); |
| 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 = NotePad.Notes.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 |
| ); |
| |
| // Tells the Cursor what URI to watch, so it knows when its source data changes |
| c.setNotificationUri(getContext().getContentResolver(), uri); |
| return c; |
| } |
| |
| /** |
| * This is called when a client calls {@link android.content.ContentResolver#getType(Uri)}. |
| * Returns the MIME data type of the URI given as a parameter. |
| * |
| * @param uri The URI whose MIME type is desired. |
| * @return The MIME type of the URI. |
| * @throws IllegalArgumentException if the incoming URI pattern is invalid. |
| */ |
| @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 notes or live folders, returns the general content type. |
| case NOTES: |
| case LIVE_FOLDER_NOTES: |
| return NotePad.Notes.CONTENT_TYPE; |
| |
| // If the pattern is for note IDs, returns the note ID content type. |
| case NOTE_ID: |
| return NotePad.Notes.CONTENT_ITEM_TYPE; |
| |
| // If the URI pattern doesn't match any permitted patterns, throws an exception. |
| default: |
| throw new IllegalArgumentException("Unknown URI " + uri); |
| } |
| } |
| |
| //BEGIN_INCLUDE(stream) |
| /** |
| * This describes the MIME types that are supported for opening a note |
| * URI as a stream. |
| */ |
| static ClipDescription NOTE_STREAM_TYPES = new ClipDescription(null, |
| new String[] { ClipDescription.MIMETYPE_TEXT_PLAIN }); |
| |
| /** |
| * Returns the types of available data streams. URIs to specific notes are supported. |
| * The application can convert such a note to a plain text stream. |
| * |
| * @param uri the URI to analyze |
| * @param mimeTypeFilter The MIME type to check for. This method only returns a data stream |
| * type for MIME types that match the filter. Currently, only text/plain MIME types match. |
| * @return a data stream MIME type. Currently, only text/plan is returned. |
| * @throws IllegalArgumentException if the URI pattern doesn't match any supported patterns. |
| */ |
| @Override |
| public String[] getStreamTypes(Uri uri, String mimeTypeFilter) { |
| /** |
| * Chooses the data stream type based on the incoming URI pattern. |
| */ |
| switch (sUriMatcher.match(uri)) { |
| |
| // If the pattern is for notes or live folders, return null. Data streams are not |
| // supported for this type of URI. |
| case NOTES: |
| case LIVE_FOLDER_NOTES: |
| return null; |
| |
| // If the pattern is for note IDs and the MIME filter is text/plain, then return |
| // text/plain |
| case NOTE_ID: |
| return NOTE_STREAM_TYPES.filterMimeTypes(mimeTypeFilter); |
| |
| // If the URI pattern doesn't match any permitted patterns, throws an exception. |
| default: |
| throw new IllegalArgumentException("Unknown URI " + uri); |
| } |
| } |
| |
| |
| /** |
| * Returns a stream of data for each supported stream type. This method does a query on the |
| * incoming URI, then uses |
| * {@link android.content.ContentProvider#openPipeHelper(Uri, String, Bundle, Object, |
| * PipeDataWriter)} to start another thread in which to convert the data into a stream. |
| * |
| * @param uri The URI pattern that points to the data stream |
| * @param mimeTypeFilter A String containing a MIME type. This method tries to get a stream of |
| * data with this MIME type. |
| * @param opts Additional options supplied by the caller. Can be interpreted as |
| * desired by the content provider. |
| * @return AssetFileDescriptor A handle to the file. |
| * @throws FileNotFoundException if there is no file associated with the incoming URI. |
| */ |
| @Override |
| public AssetFileDescriptor openTypedAssetFile(Uri uri, String mimeTypeFilter, Bundle opts) |
| throws FileNotFoundException { |
| |
| // Checks to see if the MIME type filter matches a supported MIME type. |
| String[] mimeTypes = getStreamTypes(uri, mimeTypeFilter); |
| |
| // If the MIME type is supported |
| if (mimeTypes != null) { |
| |
| // Retrieves the note for this URI. Uses the query method defined for this provider, |
| // rather than using the database query method. |
| Cursor c = query( |
| uri, // The URI of a note |
| READ_NOTE_PROJECTION, // Gets a projection containing the note's ID, title, |
| // and contents |
| null, // No WHERE clause, get all matching records |
| null, // Since there is no WHERE clause, no selection criteria |
| null // Use the default sort order (modification date, |
| // descending |
| ); |
| |
| |
| // If the query fails or the cursor is empty, stop |
| if (c == null || !c.moveToFirst()) { |
| |
| // If the cursor is empty, simply close the cursor and return |
| if (c != null) { |
| c.close(); |
| } |
| |
| // If the cursor is null, throw an exception |
| throw new FileNotFoundException("Unable to query " + uri); |
| } |
| |
| // Start a new thread that pipes the stream data back to the caller. |
| return new AssetFileDescriptor( |
| openPipeHelper(uri, mimeTypes[0], opts, c, this), 0, |
| AssetFileDescriptor.UNKNOWN_LENGTH); |
| } |
| |
| // If the MIME type is not supported, return a read-only handle to the file. |
| return super.openTypedAssetFile(uri, mimeTypeFilter, opts); |
| } |
| |
| /** |
| * Implementation of {@link android.content.ContentProvider.PipeDataWriter} |
| * to perform the actual work of converting the data in one of cursors to a |
| * stream of data for the client to read. |
| */ |
| @Override |
| public void writeDataToPipe(ParcelFileDescriptor output, Uri uri, String mimeType, |
| Bundle opts, Cursor c) { |
| // We currently only support conversion-to-text from a single note entry, |
| // so no need for cursor data type checking here. |
| FileOutputStream fout = new FileOutputStream(output.getFileDescriptor()); |
| PrintWriter pw = null; |
| try { |
| pw = new PrintWriter(new OutputStreamWriter(fout, "UTF-8")); |
| pw.println(c.getString(READ_NOTE_TITLE_INDEX)); |
| pw.println(""); |
| pw.println(c.getString(READ_NOTE_NOTE_INDEX)); |
| } catch (UnsupportedEncodingException e) { |
| Log.w(TAG, "Ooops", e); |
| } finally { |
| c.close(); |
| if (pw != null) { |
| pw.flush(); |
| } |
| try { |
| fout.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |
| //END_INCLUDE(stream) |
| |
| /** |
| * This is called when a client calls |
| * {@link android.content.ContentResolver#insert(Uri, ContentValues)}. |
| * Inserts a new row into the database. This method sets up default values for any |
| * columns that are not included in the incoming map. |
| * If rows were inserted, then listeners are notified of the change. |
| * @return The row ID of the inserted row. |
| * @throws SQLException if the insertion fails. |
| */ |
| @Override |
| public Uri insert(Uri uri, ContentValues initialValues) { |
| |
| // Validates the incoming URI. Only the full provider URI is allowed for inserts. |
| if (sUriMatcher.match(uri) != NOTES) { |
| 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 |
| values = new ContentValues(); |
| } |
| |
| // Gets the current system time in milliseconds |
| Long now = Long.valueOf(System.currentTimeMillis()); |
| |
| // If the values map doesn't contain the creation date, sets the value to the current time. |
| if (values.containsKey(NotePad.Notes.COLUMN_NAME_CREATE_DATE) == false) { |
| values.put(NotePad.Notes.COLUMN_NAME_CREATE_DATE, now); |
| } |
| |
| // If the values map doesn't contain the modification date, sets the value to the current |
| // time. |
| if (values.containsKey(NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE) == false) { |
| values.put(NotePad.Notes.COLUMN_NAME_MODIFICATION_DATE, now); |
| } |
| |
| // If the values map doesn't contain a title, sets the value to the default title. |
| if (values.containsKey(NotePad.Notes.COLUMN_NAME_TITLE) == false) { |
| Resources r = Resources.getSystem(); |
| values.put(NotePad.Notes.COLUMN_NAME_TITLE, r.getString(android.R.string.untitled)); |
| } |
| |
| // If the values map doesn't contain note text, sets the value to an empty string. |
| if (values.containsKey(NotePad.Notes.COLUMN_NAME_NOTE) == false) { |
| values.put(NotePad.Notes.COLUMN_NAME_NOTE, ""); |
| } |
| |
| // Opens the database object in "write" mode. |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| |
| // Performs the insert and returns the ID of the new note. |
| long rowId = db.insert( |
| NotePad.Notes.TABLE_NAME, // The table to insert into. |
| NotePad.Notes.COLUMN_NAME_NOTE, // 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 = ContentUris.withAppendedId(NotePad.Notes.CONTENT_ID_URI_BASE, 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); |
| } |
| |
| /** |
| * This is called when a client calls |
| * {@link android.content.ContentResolver#delete(Uri, String, String[])}. |
| * Deletes records from the database. If the incoming URI matches the note ID URI pattern, |
| * this method deletes the one record specified by the ID in the URI. Otherwise, it deletes a |
| * a set of records. The record or records must also match the input selection criteria |
| * specified by where and whereArgs. |
| * |
| * If rows were deleted, then listeners are notified of the change. |
| * @return If a "where" clause is used, the number of rows affected is returned, otherwise |
| * 0 is returned. To delete all rows and get a row count, use "1" as the where clause. |
| * @throws IllegalArgumentException if the incoming URI pattern is invalid. |
| */ |
| @Override |
| public int delete(Uri uri, String where, String[] whereArgs) { |
| |
| // Opens the database object in "write" mode. |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| String finalWhere; |
| |
| int count; |
| |
| // Does the delete based on the incoming URI pattern. |
| switch (sUriMatcher.match(uri)) { |
| |
| // If the incoming pattern matches the general pattern for notes, does a delete |
| // based on the incoming "where" columns and arguments. |
| case NOTES: |
| count = db.delete( |
| NotePad.Notes.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 note ID, does the delete based on the |
| // incoming data, but modifies the where clause to restrict it to the |
| // particular note ID. |
| case NOTE_ID: |
| /* |
| * Starts a final WHERE clause by restricting it to the |
| * desired note ID. |
| */ |
| finalWhere = |
| NotePad.Notes._ID + // The ID column name |
| " = " + // test for equality |
| uri.getPathSegments(). // the incoming note ID |
| get(NotePad.Notes.NOTE_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( |
| NotePad.Notes.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; |
| } |
| |
| /** |
| * This is called when a client calls |
| * {@link android.content.ContentResolver#update(Uri,ContentValues,String,String[])} |
| * Updates records in the database. The column names specified by the keys in the values map |
| * are updated with new data specified by the values in the map. If the incoming URI matches the |
| * note ID URI pattern, then the method updates the one record specified by the ID in the URI; |
| * otherwise, it updates a set of records. The record or records must match the input |
| * selection criteria specified by where and whereArgs. |
| * If rows were updated, then listeners are notified of the change. |
| * |
| * @param uri The URI pattern to match and update. |
| * @param values A map of column names (keys) and new values (values). |
| * @param where An SQL "WHERE" clause that selects records based on their column values. If this |
| * is null, then all records that match the URI pattern are selected. |
| * @param whereArgs An array of selection criteria. If the "where" param contains value |
| * placeholders ("?"), then each placeholder is replaced by the corresponding element in the |
| * array. |
| * @return The number of rows updated. |
| * @throws IllegalArgumentException if the incoming URI pattern is invalid. |
| */ |
| @Override |
| public int update(Uri uri, ContentValues values, String where, String[] whereArgs) { |
| |
| // 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 NOTES: |
| |
| // Does the update and returns the number of rows updated. |
| count = db.update( |
| NotePad.Notes.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 note ID, does the update based on the incoming |
| // data, but modifies the where clause to restrict it to the particular note ID. |
| case NOTE_ID: |
| // From the incoming URI, get the note ID |
| String noteId = uri.getPathSegments().get(NotePad.Notes.NOTE_ID_PATH_POSITION); |
| |
| /* |
| * Starts creating the final WHERE clause by restricting it to the incoming |
| * note ID. |
| */ |
| finalWhere = |
| NotePad.Notes._ID + // The ID column name |
| " = " + // test for equality |
| uri.getPathSegments(). // the incoming note ID |
| get(NotePad.Notes.NOTE_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( |
| NotePad.Notes.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; |
| } |
| |
| /** |
| * A test package can call this to get a handle to the database underlying NotePadProvider, |
| * so it can insert test data into the database. The test case class is responsible for |
| * instantiating the provider in a test context; {@link android.test.ProviderTestCase2} does |
| * this during the call to setUp() |
| * |
| * @return a handle to the database helper object for the provider's data. |
| */ |
| DatabaseHelper getOpenHelperForTest() { |
| return mOpenHelper; |
| } |
| } |
