| package android.content; |
| |
| import android.Manifest; |
| import android.database.Cursor; |
| import android.database.DatabaseUtils; |
| import android.database.sqlite.SQLiteDatabase; |
| import android.database.sqlite.SQLiteOpenHelper; |
| import android.database.sqlite.SQLiteQueryBuilder; |
| import android.net.Uri; |
| import android.provider.Sync; |
| import android.text.TextUtils; |
| import android.util.Config; |
| import android.util.Log; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| |
| /** |
| * ContentProvider that tracks the sync data and overall sync |
| * history on the device. |
| * |
| * @hide |
| */ |
| public class SyncStorageEngine { |
| private static final String TAG = "SyncManager"; |
| |
| private static final String DATABASE_NAME = "syncmanager.db"; |
| private static final int DATABASE_VERSION = 10; |
| |
| private static final int STATS = 1; |
| private static final int STATS_ID = 2; |
| private static final int HISTORY = 3; |
| private static final int HISTORY_ID = 4; |
| private static final int SETTINGS = 5; |
| private static final int PENDING = 7; |
| private static final int ACTIVE = 8; |
| private static final int STATUS = 9; |
| |
| private static final UriMatcher sURLMatcher = |
| new UriMatcher(UriMatcher.NO_MATCH); |
| |
| private static final HashMap<String,String> HISTORY_PROJECTION_MAP; |
| private static final HashMap<String,String> PENDING_PROJECTION_MAP; |
| private static final HashMap<String,String> ACTIVE_PROJECTION_MAP; |
| private static final HashMap<String,String> STATUS_PROJECTION_MAP; |
| |
| private final Context mContext; |
| private final SQLiteOpenHelper mOpenHelper; |
| private static SyncStorageEngine sSyncStorageEngine = null; |
| |
| static { |
| sURLMatcher.addURI("sync", "stats", STATS); |
| sURLMatcher.addURI("sync", "stats/#", STATS_ID); |
| sURLMatcher.addURI("sync", "history", HISTORY); |
| sURLMatcher.addURI("sync", "history/#", HISTORY_ID); |
| sURLMatcher.addURI("sync", "settings", SETTINGS); |
| sURLMatcher.addURI("sync", "status", STATUS); |
| sURLMatcher.addURI("sync", "active", ACTIVE); |
| sURLMatcher.addURI("sync", "pending", PENDING); |
| |
| HashMap<String,String> map; |
| PENDING_PROJECTION_MAP = map = new HashMap<String,String>(); |
| map.put(Sync.History._ID, Sync.History._ID); |
| map.put(Sync.History.ACCOUNT, Sync.History.ACCOUNT); |
| map.put(Sync.History.AUTHORITY, Sync.History.AUTHORITY); |
| |
| ACTIVE_PROJECTION_MAP = map = new HashMap<String,String>(); |
| map.put(Sync.History._ID, Sync.History._ID); |
| map.put(Sync.History.ACCOUNT, Sync.History.ACCOUNT); |
| map.put(Sync.History.AUTHORITY, Sync.History.AUTHORITY); |
| map.put("startTime", "startTime"); |
| |
| HISTORY_PROJECTION_MAP = map = new HashMap<String,String>(); |
| map.put(Sync.History._ID, "history._id as _id"); |
| map.put(Sync.History.ACCOUNT, "stats.account as account"); |
| map.put(Sync.History.AUTHORITY, "stats.authority as authority"); |
| map.put(Sync.History.EVENT, Sync.History.EVENT); |
| map.put(Sync.History.EVENT_TIME, Sync.History.EVENT_TIME); |
| map.put(Sync.History.ELAPSED_TIME, Sync.History.ELAPSED_TIME); |
| map.put(Sync.History.SOURCE, Sync.History.SOURCE); |
| map.put(Sync.History.UPSTREAM_ACTIVITY, Sync.History.UPSTREAM_ACTIVITY); |
| map.put(Sync.History.DOWNSTREAM_ACTIVITY, Sync.History.DOWNSTREAM_ACTIVITY); |
| map.put(Sync.History.MESG, Sync.History.MESG); |
| |
| STATUS_PROJECTION_MAP = map = new HashMap<String,String>(); |
| map.put(Sync.Status._ID, "status._id as _id"); |
| map.put(Sync.Status.ACCOUNT, "stats.account as account"); |
| map.put(Sync.Status.AUTHORITY, "stats.authority as authority"); |
| map.put(Sync.Status.TOTAL_ELAPSED_TIME, Sync.Status.TOTAL_ELAPSED_TIME); |
| map.put(Sync.Status.NUM_SYNCS, Sync.Status.NUM_SYNCS); |
| map.put(Sync.Status.NUM_SOURCE_LOCAL, Sync.Status.NUM_SOURCE_LOCAL); |
| map.put(Sync.Status.NUM_SOURCE_POLL, Sync.Status.NUM_SOURCE_POLL); |
| map.put(Sync.Status.NUM_SOURCE_SERVER, Sync.Status.NUM_SOURCE_SERVER); |
| map.put(Sync.Status.NUM_SOURCE_USER, Sync.Status.NUM_SOURCE_USER); |
| map.put(Sync.Status.LAST_SUCCESS_SOURCE, Sync.Status.LAST_SUCCESS_SOURCE); |
| map.put(Sync.Status.LAST_SUCCESS_TIME, Sync.Status.LAST_SUCCESS_TIME); |
| map.put(Sync.Status.LAST_FAILURE_SOURCE, Sync.Status.LAST_FAILURE_SOURCE); |
| map.put(Sync.Status.LAST_FAILURE_TIME, Sync.Status.LAST_FAILURE_TIME); |
| map.put(Sync.Status.LAST_FAILURE_MESG, Sync.Status.LAST_FAILURE_MESG); |
| map.put(Sync.Status.PENDING, Sync.Status.PENDING); |
| } |
| |
| private static final String[] STATS_ACCOUNT_PROJECTION = |
| new String[] { Sync.Stats.ACCOUNT }; |
| |
| private static final int MAX_HISTORY_EVENTS_TO_KEEP = 5000; |
| |
| private static final String SELECT_INITIAL_FAILURE_TIME_QUERY_STRING = "" |
| + "SELECT min(a) " |
| + "FROM (" |
| + " SELECT initialFailureTime AS a " |
| + " FROM status " |
| + " WHERE stats_id=? AND a IS NOT NULL " |
| + " UNION " |
| + " SELECT ? AS a" |
| + " )"; |
| |
| private SyncStorageEngine(Context context) { |
| mContext = context; |
| mOpenHelper = new SyncStorageEngine.DatabaseHelper(context); |
| sSyncStorageEngine = this; |
| } |
| |
| public static SyncStorageEngine newTestInstance(Context context) { |
| return new SyncStorageEngine(context); |
| } |
| |
| public static void init(Context context) { |
| if (sSyncStorageEngine != null) { |
| throw new IllegalStateException("already initialized"); |
| } |
| sSyncStorageEngine = new SyncStorageEngine(context); |
| } |
| |
| public static SyncStorageEngine getSingleton() { |
| if (sSyncStorageEngine == null) { |
| throw new IllegalStateException("not initialized"); |
| } |
| return sSyncStorageEngine; |
| } |
| |
| private class DatabaseHelper extends SQLiteOpenHelper { |
| DatabaseHelper(Context context) { |
| super(context, DATABASE_NAME, null, DATABASE_VERSION); |
| } |
| |
| @Override |
| public void onCreate(SQLiteDatabase db) { |
| db.execSQL("CREATE TABLE pending (" |
| + "_id INTEGER PRIMARY KEY," |
| + "authority TEXT NOT NULL," |
| + "account TEXT NOT NULL," |
| + "extras BLOB NOT NULL," |
| + "source INTEGER NOT NULL" |
| + ");"); |
| |
| db.execSQL("CREATE TABLE stats (" + |
| "_id INTEGER PRIMARY KEY," + |
| "account TEXT, " + |
| "authority TEXT, " + |
| "syncdata TEXT, " + |
| "UNIQUE (account, authority)" + |
| ");"); |
| |
| db.execSQL("CREATE TABLE history (" + |
| "_id INTEGER PRIMARY KEY," + |
| "stats_id INTEGER," + |
| "eventTime INTEGER," + |
| "elapsedTime INTEGER," + |
| "source INTEGER," + |
| "event INTEGER," + |
| "upstreamActivity INTEGER," + |
| "downstreamActivity INTEGER," + |
| "mesg TEXT);"); |
| |
| db.execSQL("CREATE TABLE status (" |
| + "_id INTEGER PRIMARY KEY," |
| + "stats_id INTEGER NOT NULL," |
| + "totalElapsedTime INTEGER NOT NULL DEFAULT 0," |
| + "numSyncs INTEGER NOT NULL DEFAULT 0," |
| + "numSourcePoll INTEGER NOT NULL DEFAULT 0," |
| + "numSourceServer INTEGER NOT NULL DEFAULT 0," |
| + "numSourceLocal INTEGER NOT NULL DEFAULT 0," |
| + "numSourceUser INTEGER NOT NULL DEFAULT 0," |
| + "lastSuccessTime INTEGER," |
| + "lastSuccessSource INTEGER," |
| + "lastFailureTime INTEGER," |
| + "lastFailureSource INTEGER," |
| + "lastFailureMesg STRING," |
| + "initialFailureTime INTEGER," |
| + "pending INTEGER NOT NULL DEFAULT 0);"); |
| |
| db.execSQL("CREATE TABLE active (" |
| + "_id INTEGER PRIMARY KEY," |
| + "authority TEXT," |
| + "account TEXT," |
| + "startTime INTEGER);"); |
| |
| db.execSQL("CREATE INDEX historyEventTime ON history (eventTime)"); |
| |
| db.execSQL("CREATE TABLE settings (" + |
| "name TEXT PRIMARY KEY," + |
| "value TEXT);"); |
| } |
| |
| @Override |
| public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { |
| if (oldVersion == 9 && newVersion == 10) { |
| Log.w(TAG, "Upgrading database from version " + oldVersion + " to " |
| + newVersion + ", which will preserve old data"); |
| db.execSQL("ALTER TABLE status ADD COLUMN initialFailureTime INTEGER"); |
| return; |
| } |
| |
| Log.w(TAG, "Upgrading database from version " + oldVersion + " to " |
| + newVersion + ", which will destroy all old data"); |
| db.execSQL("DROP TABLE IF EXISTS pending"); |
| db.execSQL("DROP TABLE IF EXISTS stats"); |
| db.execSQL("DROP TABLE IF EXISTS history"); |
| db.execSQL("DROP TABLE IF EXISTS settings"); |
| db.execSQL("DROP TABLE IF EXISTS active"); |
| db.execSQL("DROP TABLE IF EXISTS status"); |
| onCreate(db); |
| } |
| |
| @Override |
| public void onOpen(SQLiteDatabase db) { |
| if (!db.isReadOnly()) { |
| db.delete("active", null, null); |
| db.insert("active", "account", null); |
| } |
| } |
| } |
| |
| protected void doDatabaseCleanup(String[] accounts) { |
| HashSet<String> currentAccounts = new HashSet<String>(); |
| for (String account : accounts) currentAccounts.add(account); |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| Cursor cursor = db.query("stats", STATS_ACCOUNT_PROJECTION, |
| null /* where */, null /* where args */, Sync.Stats.ACCOUNT, |
| null /* having */, null /* order by */); |
| try { |
| while (cursor.moveToNext()) { |
| String account = cursor.getString(0); |
| if (TextUtils.isEmpty(account)) { |
| continue; |
| } |
| if (!currentAccounts.contains(account)) { |
| String where = Sync.Stats.ACCOUNT + "=?"; |
| int numDeleted; |
| numDeleted = db.delete("stats", where, new String[]{account}); |
| if (Config.LOGD) { |
| Log.d(TAG, "deleted " + numDeleted |
| + " records from stats table" |
| + " for account " + account); |
| } |
| } |
| } |
| } finally { |
| cursor.close(); |
| } |
| } |
| |
| protected void setActiveSync(SyncManager.ActiveSyncContext activeSyncContext) { |
| if (activeSyncContext != null) { |
| updateActiveSync(activeSyncContext.mSyncOperation.account, |
| activeSyncContext.mSyncOperation.authority, activeSyncContext.mStartTime); |
| } else { |
| // we indicate that the sync is not active by passing null for all the parameters |
| updateActiveSync(null, null, null); |
| } |
| } |
| |
| private int updateActiveSync(String account, String authority, Long startTime) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| ContentValues values = new ContentValues(); |
| values.put("account", account); |
| values.put("authority", authority); |
| values.put("startTime", startTime); |
| int numChanges = db.update("active", values, null, null); |
| if (numChanges > 0) { |
| mContext.getContentResolver().notifyChange(Sync.Active.CONTENT_URI, |
| null /* this change wasn't made through an observer */); |
| } |
| return numChanges; |
| } |
| |
| /** |
| * Implements the {@link ContentProvider#query} method |
| */ |
| public Cursor query(Uri url, String[] projectionIn, |
| String selection, String[] selectionArgs, String sort) { |
| SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); |
| |
| // Generate the body of the query |
| int match = sURLMatcher.match(url); |
| String groupBy = null; |
| switch (match) { |
| case STATS: |
| qb.setTables("stats"); |
| break; |
| case STATS_ID: |
| qb.setTables("stats"); |
| qb.appendWhere("_id="); |
| qb.appendWhere(url.getPathSegments().get(1)); |
| break; |
| case HISTORY: |
| // join the stats and history tables, so the caller can get |
| // the account and authority information as part of this query. |
| qb.setTables("stats, history"); |
| qb.setProjectionMap(HISTORY_PROJECTION_MAP); |
| qb.appendWhere("stats._id = history.stats_id"); |
| break; |
| case ACTIVE: |
| qb.setTables("active"); |
| qb.setProjectionMap(ACTIVE_PROJECTION_MAP); |
| qb.appendWhere("account is not null"); |
| break; |
| case PENDING: |
| qb.setTables("pending"); |
| qb.setProjectionMap(PENDING_PROJECTION_MAP); |
| groupBy = "account, authority"; |
| break; |
| case STATUS: |
| // join the stats and status tables, so the caller can get |
| // the account and authority information as part of this query. |
| qb.setTables("stats, status"); |
| qb.setProjectionMap(STATUS_PROJECTION_MAP); |
| qb.appendWhere("stats._id = status.stats_id"); |
| break; |
| case HISTORY_ID: |
| // join the stats and history tables, so the caller can get |
| // the account and authority information as part of this query. |
| qb.setTables("stats, history"); |
| qb.setProjectionMap(HISTORY_PROJECTION_MAP); |
| qb.appendWhere("stats._id = history.stats_id"); |
| qb.appendWhere("AND history._id="); |
| qb.appendWhere(url.getPathSegments().get(1)); |
| break; |
| case SETTINGS: |
| qb.setTables("settings"); |
| break; |
| default: |
| throw new IllegalArgumentException("Unknown URL " + url); |
| } |
| |
| if (match == SETTINGS) { |
| mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, |
| "no permission to read the sync settings"); |
| } else { |
| mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, |
| "no permission to read the sync stats"); |
| } |
| SQLiteDatabase db = mOpenHelper.getReadableDatabase(); |
| Cursor c = qb.query(db, projectionIn, selection, selectionArgs, groupBy, null, sort); |
| c.setNotificationUri(mContext.getContentResolver(), url); |
| return c; |
| } |
| |
| /** |
| * Implements the {@link ContentProvider#insert} method |
| * @param callerIsTheProvider true if this is being called via the |
| * {@link ContentProvider#insert} in method rather than directly. |
| * @throws UnsupportedOperationException if callerIsTheProvider is true and the url isn't |
| * for the Settings table. |
| */ |
| public Uri insert(boolean callerIsTheProvider, Uri url, ContentValues values) { |
| String table; |
| long rowID; |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| final int match = sURLMatcher.match(url); |
| checkCaller(callerIsTheProvider, match); |
| switch (match) { |
| case SETTINGS: |
| mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, |
| "no permission to write the sync settings"); |
| table = "settings"; |
| rowID = db.replace(table, null, values); |
| break; |
| default: |
| throw new IllegalArgumentException("Unknown URL " + url); |
| } |
| |
| |
| if (rowID > 0) { |
| mContext.getContentResolver().notifyChange(url, null /* observer */); |
| return Uri.parse("content://sync/" + table + "/" + rowID); |
| } |
| |
| return null; |
| } |
| |
| private static void checkCaller(boolean callerIsTheProvider, int match) { |
| if (callerIsTheProvider && match != SETTINGS) { |
| throw new UnsupportedOperationException( |
| "only the settings are modifiable via the ContentProvider interface"); |
| } |
| } |
| |
| /** |
| * Implements the {@link ContentProvider#delete} method |
| * @param callerIsTheProvider true if this is being called via the |
| * {@link ContentProvider#delete} in method rather than directly. |
| * @throws UnsupportedOperationException if callerIsTheProvider is true and the url isn't |
| * for the Settings table. |
| */ |
| public int delete(boolean callerIsTheProvider, Uri url, String where, String[] whereArgs) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| int match = sURLMatcher.match(url); |
| |
| int numRows; |
| switch (match) { |
| case SETTINGS: |
| mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, |
| "no permission to write the sync settings"); |
| numRows = db.delete("settings", where, whereArgs); |
| break; |
| default: |
| throw new UnsupportedOperationException("Cannot delete URL: " + url); |
| } |
| |
| if (numRows > 0) { |
| mContext.getContentResolver().notifyChange(url, null /* observer */); |
| } |
| return numRows; |
| } |
| |
| /** |
| * Implements the {@link ContentProvider#update} method |
| * @param callerIsTheProvider true if this is being called via the |
| * {@link ContentProvider#update} in method rather than directly. |
| * @throws UnsupportedOperationException if callerIsTheProvider is true and the url isn't |
| * for the Settings table. |
| */ |
| public int update(boolean callerIsTheProvider, Uri url, ContentValues initialValues, |
| String where, String[] whereArgs) { |
| switch (sURLMatcher.match(url)) { |
| case SETTINGS: |
| throw new UnsupportedOperationException("updating url " + url |
| + " is not allowed, use insert instead"); |
| default: |
| throw new UnsupportedOperationException("Cannot update URL: " + url); |
| } |
| } |
| |
| /** |
| * Implements the {@link ContentProvider#getType} method |
| */ |
| public String getType(Uri url) { |
| int match = sURLMatcher.match(url); |
| switch (match) { |
| case SETTINGS: |
| return "vnd.android.cursor.dir/sync-settings"; |
| default: |
| throw new IllegalArgumentException("Unknown URL"); |
| } |
| } |
| |
| protected Uri insertIntoPending(ContentValues values) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| try { |
| db.beginTransaction(); |
| long rowId = db.insert("pending", Sync.Pending.ACCOUNT, values); |
| if (rowId < 0) return null; |
| String account = values.getAsString(Sync.Pending.ACCOUNT); |
| String authority = values.getAsString(Sync.Pending.AUTHORITY); |
| |
| long statsId = createStatsRowIfNecessary(account, authority); |
| createStatusRowIfNecessary(statsId); |
| |
| values.clear(); |
| values.put(Sync.Status.PENDING, 1); |
| int numUpdatesStatus = db.update("status", values, "stats_id=" + statsId, null); |
| |
| db.setTransactionSuccessful(); |
| |
| mContext.getContentResolver().notifyChange(Sync.Pending.CONTENT_URI, |
| null /* no observer initiated this change */); |
| if (numUpdatesStatus > 0) { |
| mContext.getContentResolver().notifyChange(Sync.Status.CONTENT_URI, |
| null /* no observer initiated this change */); |
| } |
| return ContentUris.withAppendedId(Sync.Pending.CONTENT_URI, rowId); |
| } finally { |
| db.endTransaction(); |
| } |
| } |
| |
| int deleteFromPending(long rowId) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| db.beginTransaction(); |
| try { |
| String account; |
| String authority; |
| Cursor c = db.query("pending", |
| new String[]{Sync.Pending.ACCOUNT, Sync.Pending.AUTHORITY}, |
| "_id=" + rowId, null, null, null, null); |
| try { |
| if (c.getCount() != 1) { |
| return 0; |
| } |
| c.moveToNext(); |
| account = c.getString(0); |
| authority = c.getString(1); |
| } finally { |
| c.close(); |
| } |
| db.delete("pending", "_id=" + rowId, null /* no where args */); |
| final String[] accountAuthorityWhereArgs = new String[]{account, authority}; |
| boolean isPending = 0 < DatabaseUtils.longForQuery(db, |
| "SELECT COUNT(*) FROM PENDING WHERE account=? AND authority=?", |
| accountAuthorityWhereArgs); |
| if (!isPending) { |
| long statsId = createStatsRowIfNecessary(account, authority); |
| db.execSQL("UPDATE status SET pending=0 WHERE stats_id=" + statsId); |
| } |
| db.setTransactionSuccessful(); |
| |
| mContext.getContentResolver().notifyChange(Sync.Pending.CONTENT_URI, |
| null /* no observer initiated this change */); |
| if (!isPending) { |
| mContext.getContentResolver().notifyChange(Sync.Status.CONTENT_URI, |
| null /* no observer initiated this change */); |
| } |
| return 1; |
| } finally { |
| db.endTransaction(); |
| } |
| } |
| |
| int clearPending() { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| db.beginTransaction(); |
| try { |
| int numChanges = db.delete("pending", null, null /* no where args */); |
| if (numChanges > 0) { |
| db.execSQL("UPDATE status SET pending=0"); |
| mContext.getContentResolver().notifyChange(Sync.Pending.CONTENT_URI, |
| null /* no observer initiated this change */); |
| mContext.getContentResolver().notifyChange(Sync.Status.CONTENT_URI, |
| null /* no observer initiated this change */); |
| } |
| db.setTransactionSuccessful(); |
| return numChanges; |
| } finally { |
| db.endTransaction(); |
| } |
| } |
| |
| /** |
| * Returns a cursor over all the pending syncs in no particular order. This cursor is not |
| * "live", in that if changes are made to the pending table any observers on this cursor |
| * will not be notified. |
| * @param projection Return only these columns. If null then all columns are returned. |
| * @return the cursor of pending syncs |
| */ |
| public Cursor getPendingSyncsCursor(String[] projection) { |
| SQLiteDatabase db = mOpenHelper.getReadableDatabase(); |
| return db.query("pending", projection, null, null, null, null, null); |
| } |
| |
| // @VisibleForTesting |
| static final long MILLIS_IN_4WEEKS = 1000L * 60 * 60 * 24 * 7 * 4; |
| |
| private boolean purgeOldHistoryEvents(long now) { |
| // remove events that are older than MILLIS_IN_4WEEKS |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| int numDeletes = db.delete("history", "eventTime<" + (now - MILLIS_IN_4WEEKS), null); |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| if (numDeletes > 0) { |
| Log.v(TAG, "deleted " + numDeletes + " old event(s) from the sync history"); |
| } |
| } |
| |
| // keep only the last MAX_HISTORY_EVENTS_TO_KEEP history events |
| numDeletes += db.delete("history", "eventTime < (select min(eventTime) from " |
| + "(select eventTime from history order by eventTime desc limit ?))", |
| new String[]{String.valueOf(MAX_HISTORY_EVENTS_TO_KEEP)}); |
| |
| return numDeletes > 0; |
| } |
| |
| public long insertStartSyncEvent(String account, String authority, long now, int source) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| long statsId = createStatsRowIfNecessary(account, authority); |
| |
| purgeOldHistoryEvents(now); |
| ContentValues values = new ContentValues(); |
| values.put(Sync.History.STATS_ID, statsId); |
| values.put(Sync.History.EVENT_TIME, now); |
| values.put(Sync.History.SOURCE, source); |
| values.put(Sync.History.EVENT, Sync.History.EVENT_START); |
| long rowId = db.insert("history", null, values); |
| mContext.getContentResolver().notifyChange(Sync.History.CONTENT_URI, null /* observer */); |
| mContext.getContentResolver().notifyChange(Sync.Status.CONTENT_URI, null /* observer */); |
| return rowId; |
| } |
| |
| public void stopSyncEvent(long historyId, long elapsedTime, String resultMessage, |
| long downstreamActivity, long upstreamActivity) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| db.beginTransaction(); |
| try { |
| ContentValues values = new ContentValues(); |
| values.put(Sync.History.ELAPSED_TIME, elapsedTime); |
| values.put(Sync.History.EVENT, Sync.History.EVENT_STOP); |
| values.put(Sync.History.MESG, resultMessage); |
| values.put(Sync.History.DOWNSTREAM_ACTIVITY, downstreamActivity); |
| values.put(Sync.History.UPSTREAM_ACTIVITY, upstreamActivity); |
| |
| int count = db.update("history", values, "_id=?", |
| new String[]{Long.toString(historyId)}); |
| // We think that count should always be 1 but don't want to change this until after |
| // launch. |
| if (count > 0) { |
| int source = (int) DatabaseUtils.longForQuery(db, |
| "SELECT source FROM history WHERE _id=" + historyId, null); |
| long eventTime = DatabaseUtils.longForQuery(db, |
| "SELECT eventTime FROM history WHERE _id=" + historyId, null); |
| long statsId = DatabaseUtils.longForQuery(db, |
| "SELECT stats_id FROM history WHERE _id=" + historyId, null); |
| |
| createStatusRowIfNecessary(statsId); |
| |
| // update the status table to reflect this sync |
| StringBuilder sb = new StringBuilder(); |
| ArrayList<String> bindArgs = new ArrayList<String>(); |
| sb.append("UPDATE status SET"); |
| sb.append(" numSyncs=numSyncs+1"); |
| sb.append(", totalElapsedTime=totalElapsedTime+" + elapsedTime); |
| switch (source) { |
| case Sync.History.SOURCE_LOCAL: |
| sb.append(", numSourceLocal=numSourceLocal+1"); |
| break; |
| case Sync.History.SOURCE_POLL: |
| sb.append(", numSourcePoll=numSourcePoll+1"); |
| break; |
| case Sync.History.SOURCE_USER: |
| sb.append(", numSourceUser=numSourceUser+1"); |
| break; |
| case Sync.History.SOURCE_SERVER: |
| sb.append(", numSourceServer=numSourceServer+1"); |
| break; |
| } |
| |
| final String statsIdString = String.valueOf(statsId); |
| final long lastSyncTime = (eventTime + elapsedTime); |
| if (Sync.History.MESG_SUCCESS.equals(resultMessage)) { |
| // - if successful, update the successful columns |
| sb.append(", lastSuccessTime=" + lastSyncTime); |
| sb.append(", lastSuccessSource=" + source); |
| sb.append(", lastFailureTime=null"); |
| sb.append(", lastFailureSource=null"); |
| sb.append(", lastFailureMesg=null"); |
| sb.append(", initialFailureTime=null"); |
| } else if (!Sync.History.MESG_CANCELED.equals(resultMessage)) { |
| sb.append(", lastFailureTime=" + lastSyncTime); |
| sb.append(", lastFailureSource=" + source); |
| sb.append(", lastFailureMesg=?"); |
| bindArgs.add(resultMessage); |
| long initialFailureTime = DatabaseUtils.longForQuery(db, |
| SELECT_INITIAL_FAILURE_TIME_QUERY_STRING, |
| new String[]{statsIdString, String.valueOf(lastSyncTime)}); |
| sb.append(", initialFailureTime=" + initialFailureTime); |
| } |
| sb.append(" WHERE stats_id=?"); |
| bindArgs.add(statsIdString); |
| db.execSQL(sb.toString(), bindArgs.toArray()); |
| db.setTransactionSuccessful(); |
| mContext.getContentResolver().notifyChange(Sync.History.CONTENT_URI, |
| null /* observer */); |
| mContext.getContentResolver().notifyChange(Sync.Status.CONTENT_URI, |
| null /* observer */); |
| } |
| } finally { |
| db.endTransaction(); |
| } |
| } |
| |
| /** |
| * If sync is failing for any of the provider/accounts then determine the time at which it |
| * started failing and return the earliest time over all the provider/accounts. If none are |
| * failing then return 0. |
| */ |
| public long getInitialSyncFailureTime() { |
| SQLiteDatabase db = mOpenHelper.getReadableDatabase(); |
| // Join the settings for a provider with the status so that we can easily |
| // check if each provider is enabled for syncing. We also join in the overall |
| // enabled flag ("listen_for_tickles") to each row so that we don't need to |
| // make a separate DB lookup to access it. |
| Cursor c = db.rawQuery("" |
| + "SELECT initialFailureTime, s1.value, s2.value " |
| + "FROM status " |
| + "LEFT JOIN stats ON status.stats_id=stats._id " |
| + "LEFT JOIN settings as s1 ON 'sync_provider_' || authority=s1.name " |
| + "LEFT JOIN settings as s2 ON s2.name='listen_for_tickles' " |
| + "where initialFailureTime is not null " |
| + " AND lastFailureMesg!=" + Sync.History.ERROR_TOO_MANY_DELETIONS |
| + " AND lastFailureMesg!=" + Sync.History.ERROR_AUTHENTICATION |
| + " AND lastFailureMesg!=" + Sync.History.ERROR_SYNC_ALREADY_IN_PROGRESS |
| + " AND authority!='subscribedfeeds' " |
| + " ORDER BY initialFailureTime", null); |
| try { |
| while (c.moveToNext()) { |
| // these settings default to true, so if they are null treat them as enabled |
| final String providerEnabledString = c.getString(1); |
| if (providerEnabledString != null && !Boolean.parseBoolean(providerEnabledString)) { |
| continue; |
| } |
| final String allEnabledString = c.getString(2); |
| if (allEnabledString != null && !Boolean.parseBoolean(allEnabledString)) { |
| continue; |
| } |
| return c.getLong(0); |
| } |
| } finally { |
| c.close(); |
| } |
| return 0; |
| } |
| |
| private void createStatusRowIfNecessary(long statsId) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| boolean statusExists = 0 != DatabaseUtils.longForQuery(db, |
| "SELECT count(*) FROM status WHERE stats_id=" + statsId, null); |
| if (!statusExists) { |
| ContentValues values = new ContentValues(); |
| values.put("stats_id", statsId); |
| db.insert("status", null, values); |
| } |
| } |
| |
| private long createStatsRowIfNecessary(String account, String authority) { |
| SQLiteDatabase db = mOpenHelper.getWritableDatabase(); |
| StringBuilder where = new StringBuilder(); |
| where.append(Sync.Stats.ACCOUNT + "= ?"); |
| where.append(" and " + Sync.Stats.AUTHORITY + "= ?"); |
| Cursor cursor = query(Sync.Stats.CONTENT_URI, |
| Sync.Stats.SYNC_STATS_PROJECTION, |
| where.toString(), new String[] { account, authority }, |
| null /* order */); |
| try { |
| long id; |
| if (cursor.moveToFirst()) { |
| id = cursor.getLong(cursor.getColumnIndexOrThrow(Sync.Stats._ID)); |
| } else { |
| ContentValues values = new ContentValues(); |
| values.put(Sync.Stats.ACCOUNT, account); |
| values.put(Sync.Stats.AUTHORITY, authority); |
| id = db.insert("stats", null, values); |
| } |
| return id; |
| } finally { |
| cursor.close(); |
| } |
| } |
| } |