Android开发- 数据库和Content Provider

  private static class HoardDBOpenHelper extends SQLiteOpenHelper {
    
    private static final String DATABASE_NAME = "myDatabase.db";
    private static final String DATABASE_TABLE = "GoldHoards";
    private static final int DATABASE_VERSION = 1;
    
    // SQL Statement to create a new database.
    private static final String DATABASE_CREATE = "create table " +
      DATABASE_TABLE + " (" + KEY_ID +
      " integer primary key autoincrement, " +
      KEY_GOLD_HOARD_NAME_COLUMN + " text not null, " +
      KEY_GOLD_HOARDED_COLUMN + " float, " +
      KEY_GOLD_HOARD_ACCESSIBLE_COLUMN + " integer);";

    public HoardDBOpenHelper(Context context, String name,
                      CursorFactory factory, int version) {
      super(context, name, factory, version);
    }

    // Called when no database exists in disk and the helper class needs
    // to create a new one.
    @Override
    public void onCreate(SQLiteDatabase db) {
      db.execSQL(DATABASE_CREATE);
    }

    // Called when there is a database version mismatch meaning that
    // the version of the database on disk needs to be upgraded to
    // the current version.
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, 
                          int newVersion) {
      // Log the version upgrade.
      Log.w("TaskDBAdapter", "Upgrading from version " +
        oldVersion + " to " +
        newVersion + ", which will destroy all old data");

      // Upgrade the existing database to conform to the new 
      // version. Multiple previous versions can be handled by 
      // comparing oldVersion and newVersion values.

      // The simplest case is to drop the old table and create a new one.
      db.execSQL("DROP TABLE IF IT EXISTS " + DATABASE_TABLE);
      // Create a new one.
      onCreate(db);
    }
  }

Context contex=this.getApplicationContext();
        
SQLiteDatabase db=contex.openOrCreateDatabase(DATABASE_NAME,Context.MODE_PRIVATE,null);

  private Cursor getAccessibleHoard() {
    /**
     * Listing 8-3: Querying a database
     */
    // Specify the result column projection. Return the minimum set
    // of columns required to satisfy your requirements.
    String[] result_columns = new String[] { 
      KEY_ID, KEY_GOLD_HOARD_ACCESSIBLE_COLUMN, KEY_GOLD_HOARDED_COLUMN }; 
    
    // Specify the where clause that will limit our results.
    String where = KEY_GOLD_HOARD_ACCESSIBLE_COLUMN + "=" + 1;
    
    // Replace these with valid SQL statements as necessary.
    String whereArgs[] = null;
    String groupBy = null;
    String having = null;
    String order = null;
    
    SQLiteDatabase db = hoardDBOpenHelper.getWritableDatabase();
    Cursor cursor = db.query(HoardDBOpenHelper.DATABASE_TABLE, 
                             result_columns, where,
                             whereArgs, groupBy, having, order);
    //
    return cursor;
  }

  public float getAverageAccessibleHoardValue() {
    Cursor cursor = getAccessibleHoard();
    
    /**
     * Listing 8-4: Extracting values from a Cursor
     */
    float totalHoard = 0f;
    float averageHoard = 0f;

    // Find the index to the column(s) being used.
    int GOLD_HOARDED_COLUMN_INDEX =
      cursor.getColumnIndexOrThrow(KEY_GOLD_HOARDED_COLUMN);

    // Iterate over the cursors rows. 
    // The Cursor is initialized at before first, so we can 
    // check only if there is a "next" row available. If the
    // result Cursor is empty this will return false.
    while (cursor.moveToNext()) {
      float hoard = cursor.getFloat(GOLD_HOARDED_COLUMN_INDEX);
      totalHoard += hoard;
    }

    // Calculate an average -- checking for divide by zero errors.
    float cursorCount = cursor.getCount();
    averageHoard = cursorCount > 0 ? 
                     (totalHoard / cursorCount) : Float.NaN;

    // Close the Cursor when you‘ve finished with it.
    cursor.close();
    
    return averageHoard;
  }

  public void addNewHoard(String hoardName, float hoardValue, boolean hoardAccessible) {
    /**
     * Listing 8-5: Inserting new rows into a database
     */
    // Create a new row of values to insert.
    ContentValues newValues = new ContentValues();
  
    // Assign values for each row.
    newValues.put(KEY_GOLD_HOARD_NAME_COLUMN, hoardName);
    newValues.put(KEY_GOLD_HOARDED_COLUMN, hoardValue);
    newValues.put(KEY_GOLD_HOARD_ACCESSIBLE_COLUMN, hoardAccessible);
    // [ ... Repeat for each column / value pair ... ]
  
    // Insert the row into your table
    SQLiteDatabase db = hoardDBOpenHelper.getWritableDatabase();
    /*
    第二个参数称为null列侵入（null column hack）
    如果想在SQLite中添加一个空行，在传入一个空的ContentValues时，还必须传入一个值可以显示设置为null的列的名称。
    向一个SQLite数据库插入一个新行时，必须显示地指定至少一个列及对于的值，这个值可以是null。
    如果将null column hack参数设定为null，那么在插入一个空的ContentValues对象时，SQLite将抛出一个异常。
     */
    db.insert(HoardDBOpenHelper.DATABASE_TABLE, null, newValues); 
  }

  public void updateHoardValue(int hoardId, float newHoardValue) {
    /**
     * Listing 8-6: Updating a database row
     */
    // Create the updated row Content Values.
    ContentValues updatedValues = new ContentValues();
  
    // Assign values for each row.
    updatedValues.put(KEY_GOLD_HOARDED_COLUMN, newHoardValue);
    // [ ... Repeat for each column to update ... ]
  
    // Specify a where clause the defines which rows should be
    // updated. Specify where arguments as necessary.
    String where = KEY_ID + "=" + hoardId;
    String whereArgs[] = null;
  
    // Update the row with the specified index with the new values.
    SQLiteDatabase db = hoardDBOpenHelper.getWritableDatabase();
    db.update(HoardDBOpenHelper.DATABASE_TABLE, updatedValues, 
              where, whereArgs);
  }

  public void deleteEmptyHoards() {
    /**
     * Listing 8-7: Deleting a database row
     */
    // Specify a where clause that determines which row(s) to delete.
    // Specify where arguments as necessary.
    String where = KEY_GOLD_HOARDED_COLUMN + "=" + 0;
    String whereArgs[] = null;
  
    // Delete the rows that match the where clause.
    SQLiteDatabase db = hoardDBOpenHelper.getWritableDatabase();
    db.delete(HoardDBOpenHelper.DATABASE_TABLE, where, whereArgs);
  }

public class MyContentProvider extends ContentProvider

<provider android:name=".MyContentProvider"
      android:authorities="com.paad.skeletondatabaseprovider"/>

  /**
   * Listing 8-8: Defining a UriMatcher to determine if a request is for all elements or a single row
   */
  //Create the constants used to differentiate between the different URI
  //requests.
  private static final int ALLROWS = 1;
  private static final int SINGLE_ROW = 2;
  
  private static final UriMatcher uriMatcher;
  
  //Populate the UriMatcher object, where a URI ending in 
  //‘elements‘ will correspond to a request for all items,
  //and ‘elements/[rowID]‘ represents a single row.
  static {
   uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider", 
                     "elements", ALLROWS);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider", 
                     "elements/#", SINGLE_ROW);
  }

    // Use an SQLite Query Builder to simplify constructing the 
    // database query.
    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();

    // If this is a row query, limit the result set to the passed in row.
    switch (uriMatcher.match(uri)) {
      case SINGLE_ROW : 
        String rowID = uri.getPathSegments().get(1);
        queryBuilder.appendWhere(KEY_ID + "=" + rowID);
      default: break;
    }

private static class MySQLiteOpenHelper extends SQLiteOpenHelper {
    public MySQLiteOpenHelper(Context context, String name,
                      CursorFactory factory, int version) {
      super(context, name, factory, version);
    }
}

public class MyContentProvider extends ContentProvider {
  private MySQLiteOpenHelper myOpenHelper;

  @Override
  public boolean onCreate() {
    // Construct the underlying database.
    // Defer opening the database until you need to perform
    // a query or transaction.
    myOpenHelper = new MySQLiteOpenHelper(getContext(),
        MySQLiteOpenHelper.DATABASE_NAME, null, 
        MySQLiteOpenHelper.DATABASE_VERSION);
    
    return true;
  }
}

public class MyContentProvider extends ContentProvider {
  @Override
  public Cursor query(Uri uri, String[] projection, String selection,
    String[] selectionArgs, String sortOrder) {

    // Open thedatabase.
    SQLiteDatabase db;
    try {
      db = myOpenHelper.getWritableDatabase();
    } catch (SQLiteException ex) {
      db = myOpenHelper.getReadableDatabase();
    }

    // Replace these with valid SQL statements if necessary.
    String groupBy = null;
    String having = null;
    
    // Use an SQLite Query Builder to simplify constructing the 
    // database query.
    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();

    // If this is a row query, limit the result set to the passed in row.
    switch (uriMatcher.match(uri)) {
      case SINGLE_ROW : 
        String rowID = uri.getPathSegments().get(1);
        queryBuilder.appendWhere(KEY_ID + "=" + rowID);
      default: break;
    }

    // Specify the table on which to perform the query. This can 
    // be a specific table or a join as required.  
    queryBuilder.setTables(MySQLiteOpenHelper.DATABASE_TABLE);

    // Execute the query.
    Cursor cursor = queryBuilder.query(db, projection, selection,
        selectionArgs, groupBy, having, sortOrder);

    // Return the result Cursor.
    return cursor;
  }
}

  @Override
  public String getType(Uri uri) {
    // Return a string that identifies the MIME type
    // for a Content Provider URI
    switch (uriMatcher.match(uri)) {
      case ALLROWS:
        return "vnd.android.cursor.dir/vnd.paad.elemental";
      case SINGLE_ROW: 
        return "vnd.android.cursor.item/vnd.paad.elemental";
      default: 
        throw new IllegalArgumentException("Unsupported URI: " +
                                             uri);
    }
  }

public class MyContentProvider extends ContentProvider {
  @Override
  public int delete(Uri uri, String selection, String[] selectionArgs) {
    // Open a read / write database to support the transaction.
    SQLiteDatabase db = myOpenHelper.getWritableDatabase();
    
    // If this is a row URI, limit the deletion to the specified row.
    switch (uriMatcher.match(uri)) {
      case SINGLE_ROW : 
        String rowID = uri.getPathSegments().get(1);
        selection = KEY_ID + "=" + rowID
            + (!TextUtils.isEmpty(selection) ? 
              " AND (" + selection + ‘)‘ : "");
      default: break;
    }
    
    // To return the number of deleted items you must specify a where
    // clause. To delete all rows and return a value pass in "1".
    if (selection == null)
      selection = "1";

    // Perform the deletion.
    int deleteCount = db.delete(MySQLiteOpenHelper.DATABASE_TABLE, 
      selection, selectionArgs);
    
    // Notify any observers of the change in the data set.
    getContext().getContentResolver().notifyChange(uri, null);
    
    // Return the number of deleted items.
    return deleteCount;
  }

  @Override
  public Uri insert(Uri uri, ContentValues values) {
    // Open a read / write database to support the transaction.
    SQLiteDatabase db = myOpenHelper.getWritableDatabase();
    
    // To add empty rows to your database by passing in an empty 
    // Content Values object you must use the null column hack
    // parameter to specify the name of the column that can be 
    // set to null.
    String nullColumnHack = null;
    
    // Insert the values into the table
    long id = db.insert(MySQLiteOpenHelper.DATABASE_TABLE, 
        nullColumnHack, values);
    
    // Construct and return the URI of the newly inserted row.
    if (id > -1) {
      // Construct and return the URI of the newly inserted row.
      Uri insertedId = ContentUris.withAppendedId(CONTENT_URI, id);
        
      // Notify any observers of the change in the data set.
      getContext().getContentResolver().notifyChange(insertedId, null);
        
      return insertedId;
    }
    else
      return null;
  }

  @Override
  public int update(Uri uri, ContentValues values, String selection,
    String[] selectionArgs) {
    
    // Open a read / write database to support the transaction.
    SQLiteDatabase db = myOpenHelper.getWritableDatabase();
    
    // If this is a row URI, limit the deletion to the specified row.
    switch (uriMatcher.match(uri)) {
      case SINGLE_ROW : 
        String rowID = uri.getPathSegments().get(1);
        selection = KEY_ID + "=" + rowID
            + (!TextUtils.isEmpty(selection) ? 
              " AND (" + selection + ‘)‘ : "");
      default: break;
    }

    // Perform the update.
    int updateCount = db.update(MySQLiteOpenHelper.DATABASE_TABLE, 
      values, selection, selectionArgs);
    
    // Notify any observers of the change in the data set.
    getContext().getContentResolver().notifyChange(uri, null);
    
    return updateCount;
  }
}

public class MyHoardContentProvider extends ContentProvider {
  @Override
  public ParcelFileDescriptor openFile(Uri uri, String mode) 
    throws FileNotFoundException {

    // Find the row ID and use it as a filename.
    String rowID = uri.getPathSegments().get(1);
    
    // Create a file object in the application‘s external 
    // files directory.
    String picsDir = Environment.DIRECTORY_PICTURES;
    File file = 
      new File(getContext().getExternalFilesDir(picsDir), rowID);
    
    // If the file doesn‘t exist, create it now.
    if (!file.exists()) {
      try {
        file.createNewFile();
      } catch (IOException e) {
        Log.d(TAG, "File creation failed: " + e.getMessage());
      }
    }
    
    // Translate the mode parameter to the corresponding Parcel File
    // Descriptor open mode.
    int fileMode = 0;  
    if (mode.contains("w"))
      fileMode |= ParcelFileDescriptor.MODE_WRITE_ONLY;
    if (mode.contains("r")) 
      fileMode |= ParcelFileDescriptor.MODE_READ_ONLY;
    if (mode.contains("+")) 
      fileMode |= ParcelFileDescriptor.MODE_APPEND;     

    // Return a Parcel File Descriptor that represents the file.
    return ParcelFileDescriptor.open(file, fileMode);
  }
}

ContentResolver cr = getContentResolver();

    // Get the Content Resolver.
    ContentResolver cr = getContentResolver();
  
    // Specify the result column projection. Return the minimum set
    // of columns required to satisfy your requirements.
    String[] result_columns = new String[] { 
      MyHoardContentProvider.KEY_ID, 
      MyHoardContentProvider.KEY_GOLD_HOARD_ACCESSIBLE_COLUMN,
      MyHoardContentProvider.KEY_GOLD_HOARDED_COLUMN }; 
  
    // Specify the where clause that will limit your results.
    String where = MyHoardContentProvider.KEY_GOLD_HOARD_ACCESSIBLE_COLUMN 
                   + "=" + 1;
  
    // Replace these with valid SQL statements as necessary.
    String whereArgs[] = null;
    String order = null;
  
    // Return the specified rows.
    Cursor resultCursor = cr.query(MyHoardContentProvider.CONTENT_URI, 
      result_columns, where, whereArgs, order);

  private Cursor getRow(long rowId) {
    /**
     * Listing 8-16: Querying a Content Provider for a particular row
     */
    // Get the Content Resolver.
    ContentResolver cr = getContentResolver();
  
    // Specify the result column projection. Return the minimum set
    // of columns required to satisfy your requirements.
    String[] result_columns = new String[] { 
      MyHoardContentProvider.KEY_ID, 
      MyHoardContentProvider.KEY_GOLD_HOARD_NAME_COLUMN,
      MyHoardContentProvider.KEY_GOLD_HOARDED_COLUMN }; 
  
    // Append a row ID to the URI to address a specific row.
    Uri rowAddress =
      ContentUris.withAppendedId(MyHoardContentProvider.CONTENT_URI, 
      rowId); 
  
    // These are null as we are requesting a single row.
    String where = null;
    String whereArgs[] = null;
    String order = null;
  
    // Return the specified rows.
    Cursor resultCursor = cr.query(rowAddress, 
      result_columns, where, whereArgs, order);
    
    return resultCursor;
  }

public class PersonContentProvider extends ContentProvider {
   public Uri insert(Uri uri, ContentValues values) {
      db.insert("person", "personid", values);
      getContext().getContentResolver().notifyChange(uri, null);
   }
}

getContentResolver().registerContentObserver(Uri.parse("content://com.ljq.providers.personprovider/person"),
       true, new PersonObserver(new Handler()));
public class PersonObserver extends ContentObserver{
   public PersonObserver(Handler handler) {
      super(handler);
   }
   public void onChange(boolean selfChange) {
      //此处可以进行相应的业务处理
   }
}

public class MyContentProvider extends ContentProvider {
    public static final Uri CONTENT_URI = Uri.parse("content://com.paad.skeletondatabaseprovider/elements");
}

public class DatabaseSkeletonActivity extends Activity {
  LoaderManager.LoaderCallbacks<Cursor> loaderCallback = new LoaderManager.LoaderCallbacks<Cursor>() {
    /**
     * Listing 8-18: Implementing Loader Callbacks
     */
    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
      // Construct the new query in the form of a Cursor Loader. Use the id
      // parameter to contruct and return different loaders.
      String[] projection = null;
      String where = null;
      String[] whereArgs = null;
      String sortOrder = null;
        
      // Query URI
      Uri queryUri = MyContentProvider.CONTENT_URI;
        
      // Create the new Cursor loader.
      return new CursorLoader(DatabaseSkeletonActivity.this, queryUri,
        projection, where, whereArgs, sortOrder);
    }

    public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
      // Replace the result Cursor displayed by the Cursor Adapter with  
      // the new result set.
      adapter.swapCursor(cursor);

      // This handler is not synchonrized with the UI thread, so you 
      // will need to synchronize it before modiyfing any UI elements
      // directly.
    }

    public void onLoaderReset(Loader<Cursor> loader) {
      // Remove the existing result Cursor from the List Adapter.
      adapter.swapCursor(null);

      // This handler is not synchonrized with the UI thread, so you 
      // will need to synchronize it before modiyfing any UI elements
      // directly.
    }
  };
}

public class DatabaseSkeletonSearchActivity extends ListActivity 
  implements LoaderManager.LoaderCallbacks<Cursor> {
  
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  
      // Initiate the Cursor Loader
    getLoaderManager().initLoader(0, null, this);
  }
  
  public Loader<Cursor> onCreateLoader(int id, Bundle args) {
    String query = "0";

    // Extract the search query from the arguments.
    if (args != null)
      query = args.getString(QUERY_EXTRA_KEY);

    // Construct the new query in the form of a Cursor Loader.
    String[] projection = { 
        MyContentProvider.KEY_ID, 
        MyContentProvider.KEY_COLUMN_1_NAME 
    };
    String where = MyContentProvider.KEY_COLUMN_1_NAME 
                   + " LIKE \"%" + query + "%\"";
    String[] whereArgs = null;
    String sortOrder = MyContentProvider.KEY_COLUMN_1_NAME + 
                       " COLLATE LOCALIZED ASC";
    
    // Create the new Cursor loader.
    return new CursorLoader(this, MyContentProvider.CONTENT_URI,
      projection, where, whereArgs, sortOrder);
  }

  public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
    // Replace the result Cursor displayed by the Cursor Adapter with
    // the new result set.
    adapter.swapCursor(cursor);
  }

  public void onLoaderReset(Loader<Cursor> loader) {
    // Remove the existing result Cursor from the List Adapter.
    adapter.swapCursor(null);
  }
}

    // Restart the Cursor Loader to execute the new query.
    getLoaderManager().restartLoader(0, args, this);

    ContentValues newValues = new ContentValues();
  
    // Assign values for each row.
    newValues.put(MyHoardContentProvider.KEY_GOLD_HOARD_NAME_COLUMN,
                  hoardName);
    newValues.put(MyHoardContentProvider.KEY_GOLD_HOARDED_COLUMN,
                  hoardValue);
    newValues.put(MyHoardContentProvider.KEY_GOLD_HOARD_ACCESSIBLE_COLUMN,
                  hoardAccessible);
    // [ ... Repeat for each column / value pair ... ]
  
    // Get the Content Resolver
    ContentResolver cr = getContentResolver();
  
    // Insert the row into your table
    Uri myRowUri = cr.insert(MyHoardContentProvider.CONTENT_URI,
                             newValues);

    // Create the updated row content, assigning values for each row.
    ContentValues updatedValues = new ContentValues();
    updatedValues.put(MyHoardContentProvider.KEY_GOLD_HOARDED_COLUMN, 
                      newHoardValue);
    // [ ... Repeat for each column to update ... ]
  
    // Create a URI addressing a specific row.
    Uri rowURI = 
      ContentUris.withAppendedId(MyHoardContentProvider.CONTENT_URI,
      hoardId);
  
    // Specify a specific row so no selection clause is required.
    String where = null;
    String whereArgs[] = null;
  
    // Get the Content Resolver.
    ContentResolver cr = getContentResolver();
  
    // Update the specified row.
    int updatedRowCount = 
      cr.update(rowURI, updatedValues, where, whereArgs);

    // Specify a where clause that determines which row(s) to delete.
    // Specify where arguments as necessary.
    String where = MyHoardContentProvider.KEY_GOLD_HOARDED_COLUMN + 
                   "=" + 0;
    String whereArgs[] = null;
  
    // Get the Content Resolver.
    ContentResolver cr = getContentResolver();
  
    // Delete the matching rows
    int deletedRowCount = 
      cr.delete(MyHoardContentProvider.CONTENT_URI, where, whereArgs);

<?xml version="1.0" encoding="utf-8"?>
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
  android:label="@string/app_name"
  android:hint="@string/search_hint">
</searchable>

    <activity android:name=".DatabaseSkeletonSearchActivity" 
              android:label="Element Search"
              android:launchMode="singleTop">
      <intent-filter>
        <action android:name="android.intent.action.SEARCH" />
        <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
      <meta-data
        android:name="android.app.searchable"
        android:resource="@xml/searchable"
      />
    </activity>

<meta-data
      android:name="android.app.default_searchable"
      android:value=".DatabaseSkeletonSearchActivity"
    />

public class DatabaseSkeletonSearchActivity extends ListActivity 
  implements LoaderManager.LoaderCallbacks<Cursor> {
  
  private static String QUERY_EXTRA_KEY = "QUERY_EXTRA_KEY";
  
  private SimpleCursorAdapter adapter;
  
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    
    // Get the launch Intent
    parseIntent(getIntent());
  }
  
  @Override
  protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    parseIntent(getIntent());
  }
  
  private void parseIntent(Intent intent) {
    // If the Activity was started to service a Search request,
    // extract the search query.
    if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
      String searchQuery = intent.getStringExtra(SearchManager.QUERY);
      // Perform the search
      performSearch(searchQuery);
    }
  }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  package="com.paad.DatabaseSkeleton"
  android:versionCode="1"
  android:versionName="1.0" >
  
  <application
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name" >
    <activity
      android:label="@string/app_name"
      android:name=".DatabaseSkeletonActivity" >
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>

    <activity android:name=".DatabaseSkeletonSearchActivity" 
              android:label="Element Search"
              android:launchMode="singleTop">
      <intent-filter>
        <action android:name="android.intent.action.SEARCH" />
        <category android:name="android.intent.category.DEFAULT" />
      </intent-filter>
      <meta-data
        android:name="android.app.searchable"
        android:resource="@xml/searchable"
      />
    </activity>

    <meta-data
      android:name="android.app.default_searchable"
      android:value=".DatabaseSkeletonSearchActivity"
    />
  </application>
</manifest>

public class DatabaseSkeletonSearchActivity extends ListActivity 
  implements LoaderManager.LoaderCallbacks<Cursor> {
  
  private static String QUERY_EXTRA_KEY = "QUERY_EXTRA_KEY";
  
  private SimpleCursorAdapter adapter;
  
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
  
    // Create a new adapter and bind it to the List View
    adapter = new SimpleCursorAdapter(this,
            android.R.layout.simple_list_item_1, null,
            new String[] { MyContentProvider.KEY_COLUMN_1_NAME },
            new int[] { android.R.id.text1 }, 0);
    setListAdapter(adapter);
    
    // Get the launch Intent
    parseIntent(getIntent());
  }
  
  @Override
  protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    parseIntent(getIntent());
  }
  
  private void parseIntent(Intent intent) {
    // If the Activity was started to service a Search request,
    // extract the search query.
    if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
      String searchQuery = intent.getStringExtra(SearchManager.QUERY);
      // Perform the search
      performSearch(searchQuery);
    }
  }
  
  // Execute the search.
  private void performSearch(String query) {
    // Pass the search query as an argument to the Cursor Loader
    Bundle args = new Bundle();
    args.putString(QUERY_EXTRA_KEY, query);
    
    // Restart the Cursor Loader to execute the new query.
    getLoaderManager().restartLoader(0, args, this);
  }

  public Loader<Cursor> onCreateLoader(int id, Bundle args) {
    String query = "0";

    // Extract the search query from the arguments.
    if (args != null)
      query = args.getString(QUERY_EXTRA_KEY);

    // Construct the new query in the form of a Cursor Loader.
    String[] projection = { 
        MyContentProvider.KEY_ID, 
        MyContentProvider.KEY_COLUMN_1_NAME 
    };
    String where = MyContentProvider.KEY_COLUMN_1_NAME 
                   + " LIKE \"%" + query + "%\"";
    String[] whereArgs = null;
    String sortOrder = MyContentProvider.KEY_COLUMN_1_NAME + 
                       " COLLATE LOCALIZED ASC";
    
    // Create the new Cursor loader.
    return new CursorLoader(this, MyContentProvider.CONTENT_URI,
      projection, where, whereArgs, sortOrder);
  }

  public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
    // Replace the result Cursor displayed by the Cursor Adapter with
    // the new result set.
    adapter.swapCursor(cursor);
  }

  public void onLoaderReset(Loader<Cursor> loader) {
    // Remove the existing result Cursor from the List Adapter.
    adapter.swapCursor(null);
  }
}

  @Override
  protected void onListItemClick(ListView listView, View view, int position, long id) {
    super.onListItemClick(listView, view, position, id);
    
    // Create a URI to the selected item.
    Uri selectedUri = 
      ContentUris.withAppendedId(MyContentProvider.CONTENT_URI, id);
    
    // Create an Intent to view the selected item.
    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setData(selectedUri);
    
    // Start an Activity to view the selected item.
    startActivity(intent);
  }

     // Use the Search Manager to find the SearchableInfo related 
     // to this Activity.
     SearchManager searchManager =
       (SearchManager)getSystemService(Context.SEARCH_SERVICE);
     SearchableInfo searchableInfo = 
       searchManager.getSearchableInfo(getComponentName());
    
     // Bind the Activity‘s SearchableInfo to the Search View
     SearchView searchView = (SearchView)findViewById(R.id.searchView);
     searchView.setSearchableInfo(searchableInfo);

searchView.setIconifiedByDefault(false);

searchView.setSubmitButtonEnable(true);

  private static final int ALLROWS = 1;
  private static final int SINGLE_ROW = 2;
  private static final int SEARCH = 3;

  private static final UriMatcher uriMatcher;
  static {
   uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider", 
                     "elements", ALLROWS);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider", 
                     "elements/#", SINGLE_ROW);
   
   uriMatcher.addURI("com.paad.skeletondatabaseprovider",
     SearchManager.SUGGEST_URI_PATH_QUERY, SEARCH);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider",
     SearchManager.SUGGEST_URI_PATH_QUERY + "/*", SEARCH);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider",
     SearchManager.SUGGEST_URI_PATH_SHORTCUT, SEARCH);
   uriMatcher.addURI("com.paad.skeletondatabaseprovider",
     SearchManager.SUGGEST_URI_PATH_SHORTCUT + "/*", SEARCH);
  }

  @Override
  public String getType(Uri uri) {
    // Return a string that identifies the MIME type
    // for a Content Provider URI
    switch (uriMatcher.match(uri)) {
      case ALLROWS: 
        return "vnd.android.cursor.dir/vnd.paad.elemental";
      case SINGLE_ROW: 
        return "vnd.android.cursor.item/vnd.paad.elemental";
      case SEARCH : 
        return SearchManager.SUGGEST_MIME_TYPE;
      default: 
        throw new IllegalArgumentException("Unsupported URI: " + uri);
    }
  }

  public static final String KEY_SEARCH_COLUMN = KEY_COLUMN_1_NAME;
    
  private static final HashMap<String, String> SEARCH_SUGGEST_PROJECTION_MAP;
  static {
    SEARCH_SUGGEST_PROJECTION_MAP = new HashMap<String, String>();
    SEARCH_SUGGEST_PROJECTION_MAP.put(
      "_id", KEY_ID + " AS " + "_id");
    SEARCH_SUGGEST_PROJECTION_MAP.put(
      SearchManager.SUGGEST_COLUMN_TEXT_1,
      KEY_SEARCH_COLUMN + " AS " + SearchManager.SUGGEST_COLUMN_TEXT_1);
    SEARCH_SUGGEST_PROJECTION_MAP.put(
      SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID, KEY_ID + 
      " AS " + "_id");
  }

  @Override
  public Cursor query(Uri uri, String[] projection, String selection,
      String[] selectionArgs, String sortOrder) {
    // Open a read-only database.
    SQLiteDatabase db = myOpenHelper.getWritableDatabase();

    // Replace these with valid SQL statements if necessary.
    String groupBy = null;
    String having = null;
    
    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
    queryBuilder.setTables(MySQLiteOpenHelper.DATABASE_TABLE);
    
    // If this is a row query, limit the result set to the passed in row.
    switch (uriMatcher.match(uri)) {
      case SINGLE_ROW : 
        String rowID = uri.getPathSegments().get(1);
        queryBuilder.appendWhere(KEY_ID + "=" + rowID);
        break;
      case SEARCH : 
        String query = uri.getPathSegments().get(1);
        queryBuilder.appendWhere(KEY_SEARCH_COLUMN + 
          " LIKE \"%" + query + "%\"");
        queryBuilder.setProjectionMap(SEARCH_SUGGEST_PROJECTION_MAP); 
        break;
      default: break;
    }
    
    Cursor cursor = queryBuilder.query(db, projection, selection,
        selectionArgs, groupBy, having, sortOrder);

    return cursor;
  }

<?xml version="1.0" encoding="utf-8"?>
<searchable xmlns:android="http://schemas.android.com/apk/res/android"
  android:label="@string/app_name"
  android:searchSuggestAuthority=
    "com.paad.skeletonsearchabledatabaseprovider"
  android:searchSuggestIntentAction="android.intent.action.VIEW"
  android:searchSuggestIntentData=
    "content://com.paad.skeletonsearchabledatabaseprovider/elements">
</searchable>

  private String[] getSongListing() {
    // Get a Cursor over every piece of audio on the external volume, 
    // extracting the song title and album name.
    String[] projection = new String[] {
      MediaStore.Audio.AudioColumns.ALBUM,
      MediaStore.Audio.AudioColumns.TITLE
    };
  
    Uri contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  
    Cursor cursor = 
      getContentResolver().query(contentUri, projection, 
                                 null, null, null); 
  
    // Get the index of the columns we need.
    int albumIdx =
      cursor.getColumnIndexOrThrow(MediaStore.Audio.AudioColumns.ALBUM);
    int titleIdx = 
      cursor.getColumnIndexOrThrow(MediaStore.Audio.AudioColumns.TITLE);
  
    // Create an array to store the result set.
    String[] result = new String[cursor.getCount()];
  
    // Iterate over the Cursor, extracting each album name and song title.
    while (cursor.moveToNext()) {
      // Extract the song title.
      String title = cursor.getString(titleIdx);
      // Extract the album name.
      String album = cursor.getString(albumIdx);
  
      result[cursor.getPosition()] = title + " (" + album + ")";
    } 
  
    // Close the Cursor.
    cursor.close();

    //
    return result;
  }

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.paad.contentproviders"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="14" />
    
    <uses-permission android:name="android.permission.READ_CONTACTS"/>
    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:label="@string/app_name"
            android:name=".Ch08_ContentProvidersActivity" >
        </activity>
    </application>

</manifest>

  private String[] getNames() {
    // Create a projection that limits the result Cursor
    // to the required columns.
    String[] projection = {
      ContactsContract.Contacts._ID,
      ContactsContract.Contacts.DISPLAY_NAME
    };
  
   // Get a Cursor over the Contacts Provider.
    Cursor cursor = 
      getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,
                                 projection, null, null, null);
       
    // Get the index of the columns.
    int nameIdx = 
      cursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME);
    int idIdx = 
      cursor.getColumnIndexOrThrow(ContactsContract.Contacts._ID);
  
    // Initialize the result set.
    String[] result = new String[cursor.getCount()];
  
    // Iterate over the result Cursor.
    while(cursor.moveToNext()) {
      // Extract the name.
      String name = cursor.getString(nameIdx);
      // Extract the unique ID.
      String id = cursor.getString(idIdx);
   
      result[cursor.getPosition()] = name + " (" + id + ")";
    } 
  
    // Close the Cursor.
    cursor.close();

    //
    return result;
  }

  private String[] getNameAndNumber() {
    ContentResolver cr = getContentResolver();
    String[] result = null;

    // Find a contact using a partial name match
    String searchName = "andy";
    Uri lookupUri = 
      Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_FILTER_URI,
                           searchName);

    // Create a projection of the required column names.
    String[] projection = new String[] {
      ContactsContract.Contacts._ID
    };

    // Get a Cursor that will return the ID(s) of the matched name.
    Cursor idCursor = cr.query(lookupUri, 
      projection, null, null, null);

    // Extract the first matching ID if it exists.
    String id = null;
    if (idCursor.moveToFirst()) {
      int idIdx = 
        idCursor.getColumnIndexOrThrow(ContactsContract.Contacts._ID);
      id = idCursor.getString(idIdx);
    }

    // Close that Cursor.
    idCursor.close();

    // Create a new Cursor searching for the data associated with the returned Contact ID.
    if (id != null) {
      // Return all the PHONE data for the contact.
      String where = ContactsContract.Data.CONTACT_ID + 
        " = " + id + " AND " +
        ContactsContract.Data.MIMETYPE + " = ‘" +
        ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE +
        "‘";

      projection = new String[] {
        ContactsContract.Data.DISPLAY_NAME,
        ContactsContract.CommonDataKinds.Phone.NUMBER
      };
      
      Cursor dataCursor = 
        getContentResolver().query(ContactsContract.Data.CONTENT_URI,
          projection, where, null, null);

      // Get the indexes of the required columns.
      int nameIdx = 
        dataCursor.getColumnIndexOrThrow(ContactsContract.Data.DISPLAY_NAME);
      int phoneIdx = 
        dataCursor.getColumnIndexOrThrow(
          ContactsContract.CommonDataKinds.Phone.NUMBER);

      result = new String[dataCursor.getCount()];
      
      while(dataCursor.moveToNext()) {
        // Extract the name.
        String name = dataCursor.getString(nameIdx);
        // Extract the phone number.
        String number = dataCursor.getString(phoneIdx);

        result[dataCursor.getPosition()] = name + " (" + number + ")";
      }
      
      dataCursor.close();
    }
    
    return result;
  }

  private String performCallerId() {
    String incomingNumber = "(650)253-0000";
    String result = "Not Found";

    Uri lookupUri =
      Uri.withAppendedPath(ContactsContract.PhoneLookup.CONTENT_FILTER_URI,
                           incomingNumber);

    String[] projection = new String[] {
      ContactsContract.Contacts.DISPLAY_NAME
    };

    Cursor cursor = getContentResolver().query(lookupUri,
      projection, null, null, null);

    if (cursor.moveToFirst()) {
      int nameIdx = 
        cursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME);
      
      result = cursor.getString(nameIdx);
    }

    cursor.close();

    
    return result;
  }

  private static int PICK_CONTACT = 0;

  private void pickContact() {
    Intent intent = new Intent(Intent.ACTION_PICK,
                               ContactsContract.Contacts.CONTENT_URI);  
    startActivityForResult(intent, PICK_CONTACT);  
  }

  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if ((requestCode == PICK_CONTACT) && (resultCode == RESULT_OK)) {
      resultTextView.setText(data.getData().toString());
    }
  }

  private void insertContactWithIntent() {
    Intent intent = 
      new Intent(ContactsContract.Intents.SHOW_OR_CREATE_CONTACT,
                 ContactsContract.Contacts.CONTENT_URI);
    intent.setData(Uri.parse("tel:(650)253-0000"));

    intent.putExtra(ContactsContract.Intents.Insert.COMPANY, "Google");
    intent.putExtra(ContactsContract.Intents.Insert.POSTAL, 
      "1600 Amphitheatre Parkway, Mountain View, California");

    startActivity(intent);

  }

  private String[] queryCalendar() {
    
    //Create a projection that limits the result Cursor
    //to the required columns.
    String[] projection = {
       CalendarContract.Events._ID,
       CalendarContract.Events.TITLE
    };
    
    //Get a Cursor over the Events Provider.
    Cursor cursor = 
     getContentResolver().query(CalendarContract.Events.CONTENT_URI,
                                projection, null, null, null);

    //Get the index of the columns.
    int nameIdx = 
    cursor.getColumnIndexOrThrow(CalendarContract.Events.TITLE);
    int idIdx = cursor. getColumnIndexOrThrow(CalendarContract.Events._ID);
    
    //Initialize the result set.
    String[] result = new String[cursor.getCount()];
    
    //Iterate over the result Cursor.
    while(cursor.moveToNext()) {
      // Extract the name.
      String name = cursor.getString(nameIdx);
      // Extract the unique ID.
      String id = cursor.getString(idIdx);
    
      result[cursor.getPosition()] = name + " (" + id + ")";
    } 
    
    //Close the Cursor.
    cursor.close();
    
    //
    return result;
  }

  private void insertNewEventIntoCalendar() {

    // Create a new insertion Intent.
    Intent intent = new Intent(Intent.ACTION_INSERT, CalendarContract.Events.CONTENT_URI);

    // Add the calendar event details
    intent.putExtra(CalendarContract.Events.TITLE, "Launch!");
    intent.putExtra(CalendarContract.Events.DESCRIPTION, 
                    "Professional Android 4 " +
                    "Application Development release!");
    intent.putExtra(CalendarContract.Events.EVENT_LOCATION, "Wrox.com");
  
    Calendar startTime = Calendar.getInstance();
    startTime.set(2012, 2, 13, 0, 30);
    intent.putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, startTime.getTimeInMillis());
   
    intent.putExtra(CalendarContract.EXTRA_EVENT_ALL_DAY, true);    
  
     // Use the Calendar app to add the new event.
    startActivity(intent);
  }

  private void editCalendarEvent() {

    // Create a URI addressing a specific event by its row ID.
    // Use it to  create a new edit Intent.
    long rowID = 760;
    Uri uri = ContentUris.withAppendedId(
      CalendarContract.Events.CONTENT_URI, rowID);

    Intent intent = new Intent(Intent.ACTION_EDIT, uri);

    // Modify the calendar event details
    Calendar startTime = Calendar.getInstance();
    startTime.set(2012, 2, 13, 0, 30);
    intent.putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, startTime.getTimeInMillis());

    intent.putExtra(CalendarContract.EXTRA_EVENT_ALL_DAY, true);    

    // Use the Calendar app to edit the event.
    startActivity(intent);  
  }

  private void displayCalendarEvent() {

    // Create a URI that specifies a particular time to view.
    Calendar startTime = Calendar.getInstance();
    startTime.set(2012, 2, 13, 0, 30);

    Uri uri = Uri.parse("content://com.android.calendar/time/" +
      String.valueOf(startTime.getTimeInMillis()));
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);

    // Use the Calendar app to view the time.
    startActivity(intent);
  }