core/java/android/server/checkin/CheckinProvider.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2006 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 android.server.checkin;

 import android.content.ContentProvider;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteQueryBuilder;
 import android.net.Uri;
 import android.os.Environment;
 import android.provider.BaseColumns;
 import android.provider.Checkin;
 import android.util.Log;

 import java.io.File;

 /**
  * Content provider for the database used to store events and statistics
  * while they wait to be uploaded by the checkin service.
  */
 public class CheckinProvider extends ContentProvider {
     /** Class identifier for logging. */
     private static final String TAG = "CheckinProvider";

     /** Filename of database (in /data directory). */
     private static final String DATABASE_FILENAME = "checkin.db";

     /** Version of database schema.  */
     private static final int DATABASE_VERSION = 1;

     /** Maximum number of events recorded. */
     private static final int EVENT_LIMIT = 1000;

     /** Maximum size of individual event data. */
     private static final int EVENT_SIZE = 8192;

     /** Maximum number of crashes recorded. */
     private static final int CRASH_LIMIT = 25;

     /** Maximum size of individual crashes recorded. */
     private static final int CRASH_SIZE = 16384;

     /** Permission required for access to the 'properties' database. */
     private static final String PROPERTIES_PERMISSION =
             "android.permission.ACCESS_CHECKIN_PROPERTIES";

     /** Lock for stats read-modify-write update cycle (see {@link #insert}). */
     private final Object mStatsLock = new Object();

     /** The underlying SQLite database. */
     private SQLiteOpenHelper mOpenHelper;

     private static class OpenHelper extends SQLiteOpenHelper {
         public OpenHelper(Context context) {
             super(context, DATABASE_FILENAME, null, DATABASE_VERSION);

             // The database used to live in /data/checkin.db.
             File oldLocation = Environment.getDataDirectory();
             File old = new File(oldLocation, DATABASE_FILENAME);
             File file = context.getDatabasePath(DATABASE_FILENAME);

             // Try to move the file to the new location.
             // TODO: Remove this code before shipping.
             if (old.exists() && !file.exists() && !old.renameTo(file)) {
                Log.e(TAG, "Can't rename " + old + " to " + file);
             }
             if (old.exists() && !old.delete()) {
                // Clean up the old data file in any case.
                Log.e(TAG, "Can't remove " + old);
             }
         }

         @Override
         public void onCreate(SQLiteDatabase db) {
             db.execSQL("CREATE TABLE " + Checkin.Events.TABLE_NAME + " (" +
                     BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                     Checkin.Events.TAG + " TEXT NOT NULL," +
                     Checkin.Events.VALUE + " TEXT DEFAULT \"\"," +
                     Checkin.Events.DATE + " INTEGER NOT NULL)");

             db.execSQL("CREATE INDEX events_index ON " +
                     Checkin.Events.TABLE_NAME + " (" +
                     Checkin.Events.TAG + ")");

             db.execSQL("CREATE TABLE " + Checkin.Stats.TABLE_NAME + " (" +
                     BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                     Checkin.Stats.TAG + " TEXT UNIQUE," +
                     Checkin.Stats.COUNT + " INTEGER DEFAULT 0," +
                     Checkin.Stats.SUM + " REAL DEFAULT 0.0)");

             db.execSQL("CREATE TABLE " + Checkin.Crashes.TABLE_NAME + " (" +
                     BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                     Checkin.Crashes.DATA + " TEXT NOT NULL," +
                     Checkin.Crashes.LOGS + " TEXT)");

             db.execSQL("CREATE TABLE " + Checkin.Properties.TABLE_NAME + " (" +
                     BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
                     Checkin.Properties.TAG + " TEXT UNIQUE ON CONFLICT REPLACE,"
                     + Checkin.Properties.VALUE + " TEXT DEFAULT \"\")");
         }

         @Override
         public void onUpgrade(SQLiteDatabase db, int old, int version) {
             db.execSQL("DROP TABLE IF EXISTS " + Checkin.Events.TABLE_NAME);
             db.execSQL("DROP TABLE IF EXISTS " + Checkin.Stats.TABLE_NAME);
             db.execSQL("DROP TABLE IF EXISTS " + Checkin.Crashes.TABLE_NAME);
             db.execSQL("DROP TABLE IF EXISTS " + Checkin.Properties.TABLE_NAME);
             onCreate(db);
         }
     }

     @Override public boolean onCreate() {
         mOpenHelper = new OpenHelper(getContext());
         return true;
     }

     @Override
     public Cursor query(Uri uri, String[] select,
             String where, String[] args, String sort) {
         checkPermissions(uri);
         SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
         qb.setTables(uri.getPathSegments().get(0));
         if (uri.getPathSegments().size() == 2) {
             qb.appendWhere("_id=" + ContentUris.parseId(uri));
         } else if (uri.getPathSegments().size() != 1) {
             throw new IllegalArgumentException("Invalid query URI: " + uri);
         }

         SQLiteDatabase db = mOpenHelper.getReadableDatabase();
         Cursor cursor = qb.query(db, select, where, args, null, null, sort);
         cursor.setNotificationUri(getContext().getContentResolver(), uri);
         return cursor;
     }

     @Override
     public Uri insert(Uri uri, ContentValues values) {
         checkPermissions(uri);
         if (uri.getPathSegments().size() != 1) {
             throw new IllegalArgumentException("Invalid insert URI: " + uri);
         }

         long id;
         String table = uri.getPathSegments().get(0);
         if (Checkin.Events.TABLE_NAME.equals(table)) {
             id = insertEvent(values);
         } else if (Checkin.Stats.TABLE_NAME.equals(table)) {
             id = insertStats(values);
         } else if (Checkin.Crashes.TABLE_NAME.equals(table)) {
             id = insertCrash(values);
         } else {
             id = mOpenHelper.getWritableDatabase().insert(table, null, values);
         }

         if (id < 0) {
             return null;
         } else {
             uri = ContentUris.withAppendedId(uri, id);
             getContext().getContentResolver().notifyChange(uri, null);
             return uri;
         }
     }

     /**
      * Insert an entry into the events table.
      * Trims old events from the table to keep the size bounded.
      * @param values to insert
      * @return the row ID of the new entry
      */
     private long insertEvent(ContentValues values) {
         String value = values.getAsString(Checkin.Events.VALUE);
         if (value != null && value.length() > EVENT_SIZE) {
             // Event values are readable text, so they can be truncated.
             value = value.substring(0, EVENT_SIZE - 3) + "...";
             values.put(Checkin.Events.VALUE, value);
         }

         if (!values.containsKey(Checkin.Events.DATE)) {
             values.put(Checkin.Events.DATE, System.currentTimeMillis());
         }

         // TODO: Make this more efficient; don't do it on every insert.
         // Also, consider keeping the most recent instance of every tag,
         // and possibly update a counter when events are deleted.

         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
         db.execSQL("DELETE FROM " +
                 Checkin.Events.TABLE_NAME + " WHERE " +
                 Checkin.Events._ID + " IN (SELECT " +
                 Checkin.Events._ID + " FROM " +
                 Checkin.Events.TABLE_NAME + " ORDER BY " +
                 Checkin.Events.DATE + " DESC LIMIT -1 OFFSET " +
                 (EVENT_LIMIT - 1) + ")");
         return db.insert(Checkin.Events.TABLE_NAME, null, values);
     }

     /**
      * Add an entry into the stats table.
      * For statistics, instead of just inserting a row into the database,
      * we add the count and sum values to the existing values (if any)
      * for the specified tag.  This must be done with a lock held,
      * to avoid a race condition during the read-modify-write update.
      * @param values to insert
      * @return the row ID of the modified entry
      */
     private long insertStats(ContentValues values) {
         synchronized (mStatsLock) {
             String tag = values.getAsString(Checkin.Stats.TAG);
             if (tag == null) {
                 throw new IllegalArgumentException("Tag required:" + values);
             }

             // Look for existing values with this tag.
             SQLiteDatabase db = mOpenHelper.getWritableDatabase();
             Cursor cursor = db.query(false,
                     Checkin.Stats.TABLE_NAME,
                     new String[] {
                             Checkin.Stats._ID,
                             Checkin.Stats.COUNT,
                             Checkin.Stats.SUM
                     },
                     Checkin.Stats.TAG + "=?",
                     new String[] { tag },
                     null, null, null, null /* limit */);

             try {
                 if (cursor == null || !cursor.moveToNext()) {
                     // This is a new statistic, insert it directly.
                     return db.insert(Checkin.Stats.TABLE_NAME, null, values);
                 } else {
                     // Depend on SELECT column order to avoid getColumnIndex()
                     long id = cursor.getLong(0);
                     int count = cursor.getInt(1);
                     double sum = cursor.getDouble(2);

                     Integer countAdd = values.getAsInteger(Checkin.Stats.COUNT);
                     if (countAdd != null) count += countAdd.intValue();

                     Double sumAdd = values.getAsDouble(Checkin.Stats.SUM);
                     if (sumAdd != null) sum += sumAdd.doubleValue();

                     if (count <= 0 && sum == 0.0) {
                         // Updated to nothing: delete the row!
                         cursor.deleteRow();
                         getContext().getContentResolver().notifyChange(
                                 ContentUris.withAppendedId(Checkin.Stats.CONTENT_URI, id), null);
                         return -1;
                     } else {
                         if (countAdd != null) cursor.updateInt(1, count);
                         if (sumAdd != null) cursor.updateDouble(2, sum);
                         cursor.commitUpdates();
                         return id;
                     }
                 }
             } finally {
                 // Always clean up the cursor.
                 if (cursor != null) cursor.close();
             }
         }
     }

     /**
      * Add an entry into the crashes table.
      * @param values to insert
      * @return the row ID of the modified entry
      */
     private long insertCrash(ContentValues values) {
         try {
             int crashSize = values.getAsString(Checkin.Crashes.DATA).length();
             if (crashSize > CRASH_SIZE) {
                 // The crash is too big.  Don't report it, but do log a stat.
                 Checkin.updateStats(getContext().getContentResolver(),
                         Checkin.Stats.Tag.CRASHES_TRUNCATED, 1, 0.0);
                 throw new IllegalArgumentException("Too big: " + crashSize);
             }

             // Count the number of crashes reported, even if they roll over.
             Checkin.updateStats(getContext().getContentResolver(),
                     Checkin.Stats.Tag.CRASHES_REPORTED, 1, 0.0);

             // Trim the crashes database, if needed.
             SQLiteDatabase db = mOpenHelper.getWritableDatabase();
             db.execSQL("DELETE FROM " +
                     Checkin.Crashes.TABLE_NAME + " WHERE " +
                     Checkin.Crashes._ID + " IN (SELECT " +
                     Checkin.Crashes._ID + " FROM " +
                     Checkin.Crashes.TABLE_NAME + " ORDER BY " +
                     Checkin.Crashes._ID + " DESC LIMIT -1 OFFSET " +
                     (CRASH_LIMIT - 1) + ")");

             return db.insert(Checkin.Crashes.TABLE_NAME, null, values);
         } catch (Throwable t) {
             // To avoid an infinite crash-reporting loop, swallow the error.
             Log.e("CheckinProvider", "Error inserting crash: " + t);
             return -1;
         }
     }

     // TODO: optimize bulkInsert, especially for stats?

     @Override
     public int update(Uri uri, ContentValues values,
             String where, String[] args) {
         checkPermissions(uri);
         if (uri.getPathSegments().size() == 2) {
             if (where != null && where.length() > 0) {
                 throw new UnsupportedOperationException(
                         "WHERE clause not supported for update: " + uri);
             }
             where = "_id=" + ContentUris.parseId(uri);
             args = null;
         } else if (uri.getPathSegments().size() != 1) {
             throw new IllegalArgumentException("Invalid update URI: " + uri);
         }

         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
         int count = db.update(uri.getPathSegments().get(0), values, where, args);
         getContext().getContentResolver().notifyChange(uri, null);
         return count;
     }

     @Override
     public int delete(Uri uri, String where, String[] args) {
         checkPermissions(uri);
         if (uri.getPathSegments().size() == 2) {
             if (where != null && where.length() > 0) {
                 throw new UnsupportedOperationException(
                         "WHERE clause not supported for delete: " + uri);
             }
             where = "_id=" + ContentUris.parseId(uri);
             args = null;
         } else if (uri.getPathSegments().size() != 1) {
             throw new IllegalArgumentException("Invalid delete URI: " + uri);
         }

         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
         int count = db.delete(uri.getPathSegments().get(0), where, args);
         getContext().getContentResolver().notifyChange(uri, null);
         return count;
     }

     @Override
     public String getType(Uri uri) {
         if (uri.getPathSegments().size() == 1) {
             return "vnd.android.cursor.dir/" + uri.getPathSegments().get(0);
         } else if (uri.getPathSegments().size() == 2) {
             return "vnd.android.cursor.item/" + uri.getPathSegments().get(0);
         } else {
             throw new IllegalArgumentException("Invalid URI: " + uri);
         }
     }

     /**
      * Make sure the caller has permission to the database.
      * @param uri the caller is requesting access to
      * @throws SecurityException if the caller is forbidden.
      */
     private void checkPermissions(Uri uri) {
         if (uri.getPathSegments().size() < 1) {
             throw new IllegalArgumentException("Invalid query URI: " + uri);
         }

         String table = uri.getPathSegments().get(0);
         if (table.equals(Checkin.Properties.TABLE_NAME) &&
             getContext().checkCallingOrSelfPermission(PROPERTIES_PERMISSION) !=
                 PackageManager.PERMISSION_GRANTED) {
             throw new SecurityException("Cannot access checkin properties");
         }
     }
 }
	/*
	* Copyright (C) 2006 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 android.server.checkin;

	import android.content.ContentProvider;
	import android.content.ContentUris;
	import android.content.ContentValues;
	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.database.Cursor;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteOpenHelper;
	import android.database.sqlite.SQLiteQueryBuilder;
	import android.net.Uri;
	import android.os.Environment;
	import android.provider.BaseColumns;
	import android.provider.Checkin;
	import android.util.Log;

	import java.io.File;

	/**
	* Content provider for the database used to store events and statistics
	* while they wait to be uploaded by the checkin service.
	*/
	public class CheckinProvider extends ContentProvider {
	/** Class identifier for logging. */
	private static final String TAG = "CheckinProvider";

	/** Filename of database (in /data directory). */
	private static final String DATABASE_FILENAME = "checkin.db";

	/** Version of database schema. */
	private static final int DATABASE_VERSION = 1;

	/** Maximum number of events recorded. */
	private static final int EVENT_LIMIT = 1000;

	/** Maximum size of individual event data. */
	private static final int EVENT_SIZE = 8192;

	/** Maximum number of crashes recorded. */
	private static final int CRASH_LIMIT = 25;

	/** Maximum size of individual crashes recorded. */
	private static final int CRASH_SIZE = 16384;

	/** Permission required for access to the 'properties' database. */
	private static final String PROPERTIES_PERMISSION =
	"android.permission.ACCESS_CHECKIN_PROPERTIES";

	/** Lock for stats read-modify-write update cycle (see {@link #insert}). */
	private final Object mStatsLock = new Object();

	/** The underlying SQLite database. */
	private SQLiteOpenHelper mOpenHelper;

	private static class OpenHelper extends SQLiteOpenHelper {
	public OpenHelper(Context context) {
	super(context, DATABASE_FILENAME, null, DATABASE_VERSION);

	// The database used to live in /data/checkin.db.
	File oldLocation = Environment.getDataDirectory();
	File old = new File(oldLocation, DATABASE_FILENAME);
	File file = context.getDatabasePath(DATABASE_FILENAME);

	// Try to move the file to the new location.
	// TODO: Remove this code before shipping.
	if (old.exists() && !file.exists() && !old.renameTo(file)) {
	Log.e(TAG, "Can't rename " + old + " to " + file);
	}
	if (old.exists() && !old.delete()) {
	// Clean up the old data file in any case.
	Log.e(TAG, "Can't remove " + old);
	}
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
	db.execSQL("CREATE TABLE " + Checkin.Events.TABLE_NAME + " (" +
	BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
	Checkin.Events.TAG + " TEXT NOT NULL," +
	Checkin.Events.VALUE + " TEXT DEFAULT \"\"," +
	Checkin.Events.DATE + " INTEGER NOT NULL)");

	db.execSQL("CREATE INDEX events_index ON " +
	Checkin.Events.TABLE_NAME + " (" +
	Checkin.Events.TAG + ")");

	db.execSQL("CREATE TABLE " + Checkin.Stats.TABLE_NAME + " (" +
	BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
	Checkin.Stats.TAG + " TEXT UNIQUE," +
	Checkin.Stats.COUNT + " INTEGER DEFAULT 0," +
	Checkin.Stats.SUM + " REAL DEFAULT 0.0)");

	db.execSQL("CREATE TABLE " + Checkin.Crashes.TABLE_NAME + " (" +
	BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
	Checkin.Crashes.DATA + " TEXT NOT NULL," +
	Checkin.Crashes.LOGS + " TEXT)");

	db.execSQL("CREATE TABLE " + Checkin.Properties.TABLE_NAME + " (" +
	BaseColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
	Checkin.Properties.TAG + " TEXT UNIQUE ON CONFLICT REPLACE,"
	+ Checkin.Properties.VALUE + " TEXT DEFAULT \"\")");
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int old, int version) {
	db.execSQL("DROP TABLE IF EXISTS " + Checkin.Events.TABLE_NAME);
	db.execSQL("DROP TABLE IF EXISTS " + Checkin.Stats.TABLE_NAME);
	db.execSQL("DROP TABLE IF EXISTS " + Checkin.Crashes.TABLE_NAME);
	db.execSQL("DROP TABLE IF EXISTS " + Checkin.Properties.TABLE_NAME);
	onCreate(db);
	}
	}

	@Override public boolean onCreate() {
	mOpenHelper = new OpenHelper(getContext());
	return true;
	}

	@Override
	public Cursor query(Uri uri, String[] select,
	String where, String[] args, String sort) {
	checkPermissions(uri);
	SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
	qb.setTables(uri.getPathSegments().get(0));
	if (uri.getPathSegments().size() == 2) {
	qb.appendWhere("_id=" + ContentUris.parseId(uri));
	} else if (uri.getPathSegments().size() != 1) {
	throw new IllegalArgumentException("Invalid query URI: " + uri);
	}

	SQLiteDatabase db = mOpenHelper.getReadableDatabase();
	Cursor cursor = qb.query(db, select, where, args, null, null, sort);
	cursor.setNotificationUri(getContext().getContentResolver(), uri);
	return cursor;
	}

	@Override
	public Uri insert(Uri uri, ContentValues values) {
	checkPermissions(uri);
	if (uri.getPathSegments().size() != 1) {
	throw new IllegalArgumentException("Invalid insert URI: " + uri);
	}

	long id;
	String table = uri.getPathSegments().get(0);
	if (Checkin.Events.TABLE_NAME.equals(table)) {
	id = insertEvent(values);
	} else if (Checkin.Stats.TABLE_NAME.equals(table)) {
	id = insertStats(values);
	} else if (Checkin.Crashes.TABLE_NAME.equals(table)) {
	id = insertCrash(values);
	} else {
	id = mOpenHelper.getWritableDatabase().insert(table, null, values);
	}

	if (id < 0) {
	return null;
	} else {
	uri = ContentUris.withAppendedId(uri, id);
	getContext().getContentResolver().notifyChange(uri, null);
	return uri;
	}
	}

	/**
	* Insert an entry into the events table.
	* Trims old events from the table to keep the size bounded.
	* @param values to insert
	* @return the row ID of the new entry
	*/
	private long insertEvent(ContentValues values) {
	String value = values.getAsString(Checkin.Events.VALUE);
	if (value != null && value.length() > EVENT_SIZE) {
	// Event values are readable text, so they can be truncated.
	value = value.substring(0, EVENT_SIZE - 3) + "...";
	values.put(Checkin.Events.VALUE, value);
	}

	if (!values.containsKey(Checkin.Events.DATE)) {
	values.put(Checkin.Events.DATE, System.currentTimeMillis());
	}

	// TODO: Make this more efficient; don't do it on every insert.
	// Also, consider keeping the most recent instance of every tag,
	// and possibly update a counter when events are deleted.

	SQLiteDatabase db = mOpenHelper.getWritableDatabase();
	db.execSQL("DELETE FROM " +
	Checkin.Events.TABLE_NAME + " WHERE " +
	Checkin.Events._ID + " IN (SELECT " +
	Checkin.Events._ID + " FROM " +
	Checkin.Events.TABLE_NAME + " ORDER BY " +
	Checkin.Events.DATE + " DESC LIMIT -1 OFFSET " +
	(EVENT_LIMIT - 1) + ")");
	return db.insert(Checkin.Events.TABLE_NAME, null, values);
	}

	/**
	* Add an entry into the stats table.
	* For statistics, instead of just inserting a row into the database,
	* we add the count and sum values to the existing values (if any)
	* for the specified tag. This must be done with a lock held,
	* to avoid a race condition during the read-modify-write update.
	* @param values to insert
	* @return the row ID of the modified entry
	*/
	private long insertStats(ContentValues values) {
	synchronized (mStatsLock) {
	String tag = values.getAsString(Checkin.Stats.TAG);
	if (tag == null) {
	throw new IllegalArgumentException("Tag required:" + values);
	}

	// Look for existing values with this tag.
	SQLiteDatabase db = mOpenHelper.getWritableDatabase();
	Cursor cursor = db.query(false,
	Checkin.Stats.TABLE_NAME,
	new String[] {
	Checkin.Stats._ID,
	Checkin.Stats.COUNT,
	Checkin.Stats.SUM
	},
	Checkin.Stats.TAG + "=?",
	new String[] { tag },
	null, null, null, null /* limit */);

	try {
	if (cursor == null \|\| !cursor.moveToNext()) {
	// This is a new statistic, insert it directly.
	return db.insert(Checkin.Stats.TABLE_NAME, null, values);
	} else {
	// Depend on SELECT column order to avoid getColumnIndex()
	long id = cursor.getLong(0);
	int count = cursor.getInt(1);
	double sum = cursor.getDouble(2);

	Integer countAdd = values.getAsInteger(Checkin.Stats.COUNT);
	if (countAdd != null) count += countAdd.intValue();

	Double sumAdd = values.getAsDouble(Checkin.Stats.SUM);
	if (sumAdd != null) sum += sumAdd.doubleValue();

	if (count <= 0 && sum == 0.0) {
	// Updated to nothing: delete the row!
	cursor.deleteRow();
	getContext().getContentResolver().notifyChange(
	ContentUris.withAppendedId(Checkin.Stats.CONTENT_URI, id), null);
	return -1;
	} else {
	if (countAdd != null) cursor.updateInt(1, count);
	if (sumAdd != null) cursor.updateDouble(2, sum);
	cursor.commitUpdates();
	return id;
	}
	}
	} finally {
	// Always clean up the cursor.
	if (cursor != null) cursor.close();
	}
	}
	}

	/**
	* Add an entry into the crashes table.
	* @param values to insert
	* @return the row ID of the modified entry
	*/
	private long insertCrash(ContentValues values) {
	try {
	int crashSize = values.getAsString(Checkin.Crashes.DATA).length();
	if (crashSize > CRASH_SIZE) {
	// The crash is too big. Don't report it, but do log a stat.
	Checkin.updateStats(getContext().getContentResolver(),
	Checkin.Stats.Tag.CRASHES_TRUNCATED, 1, 0.0);
	throw new IllegalArgumentException("Too big: " + crashSize);
	}

	// Count the number of crashes reported, even if they roll over.
	Checkin.updateStats(getContext().getContentResolver(),
	Checkin.Stats.Tag.CRASHES_REPORTED, 1, 0.0);

	// Trim the crashes database, if needed.
	SQLiteDatabase db = mOpenHelper.getWritableDatabase();
	db.execSQL("DELETE FROM " +
	Checkin.Crashes.TABLE_NAME + " WHERE " +
	Checkin.Crashes._ID + " IN (SELECT " +
	Checkin.Crashes._ID + " FROM " +
	Checkin.Crashes.TABLE_NAME + " ORDER BY " +
	Checkin.Crashes._ID + " DESC LIMIT -1 OFFSET " +
	(CRASH_LIMIT - 1) + ")");

	return db.insert(Checkin.Crashes.TABLE_NAME, null, values);
	} catch (Throwable t) {
	// To avoid an infinite crash-reporting loop, swallow the error.
	Log.e("CheckinProvider", "Error inserting crash: " + t);
	return -1;
	}
	}

	// TODO: optimize bulkInsert, especially for stats?

	@Override
	public int update(Uri uri, ContentValues values,
	String where, String[] args) {
	checkPermissions(uri);
	if (uri.getPathSegments().size() == 2) {
	if (where != null && where.length() > 0) {
	throw new UnsupportedOperationException(
	"WHERE clause not supported for update: " + uri);
	}
	where = "_id=" + ContentUris.parseId(uri);
	args = null;
	} else if (uri.getPathSegments().size() != 1) {
	throw new IllegalArgumentException("Invalid update URI: " + uri);
	}

	SQLiteDatabase db = mOpenHelper.getWritableDatabase();
	int count = db.update(uri.getPathSegments().get(0), values, where, args);
	getContext().getContentResolver().notifyChange(uri, null);
	return count;
	}

	@Override
	public int delete(Uri uri, String where, String[] args) {
	checkPermissions(uri);
	if (uri.getPathSegments().size() == 2) {
	if (where != null && where.length() > 0) {
	throw new UnsupportedOperationException(
	"WHERE clause not supported for delete: " + uri);
	}
	where = "_id=" + ContentUris.parseId(uri);
	args = null;
	} else if (uri.getPathSegments().size() != 1) {
	throw new IllegalArgumentException("Invalid delete URI: " + uri);
	}

	SQLiteDatabase db = mOpenHelper.getWritableDatabase();
	int count = db.delete(uri.getPathSegments().get(0), where, args);
	getContext().getContentResolver().notifyChange(uri, null);
	return count;
	}

	@Override
	public String getType(Uri uri) {
	if (uri.getPathSegments().size() == 1) {
	return "vnd.android.cursor.dir/" + uri.getPathSegments().get(0);
	} else if (uri.getPathSegments().size() == 2) {
	return "vnd.android.cursor.item/" + uri.getPathSegments().get(0);
	} else {
	throw new IllegalArgumentException("Invalid URI: " + uri);
	}
	}

	/**
	* Make sure the caller has permission to the database.
	* @param uri the caller is requesting access to
	* @throws SecurityException if the caller is forbidden.
	*/
	private void checkPermissions(Uri uri) {
	if (uri.getPathSegments().size() < 1) {
	throw new IllegalArgumentException("Invalid query URI: " + uri);
	}

	String table = uri.getPathSegments().get(0);
	if (table.equals(Checkin.Properties.TABLE_NAME) &&
	getContext().checkCallingOrSelfPermission(PROPERTIES_PERMISSION) !=
	PackageManager.PERMISSION_GRANTED) {
	throw new SecurityException("Cannot access checkin properties");
	}
	}
	}