1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.email.provider; 18 19 import android.content.ContentProvider; 20 import android.content.ContentProviderOperation; 21 import android.content.ContentProviderResult; 22 import android.content.ContentResolver; 23 import android.content.ContentUris; 24 import android.content.ContentValues; 25 import android.content.Context; 26 import android.content.Intent; 27 import android.content.OperationApplicationException; 28 import android.content.UriMatcher; 29 import android.database.ContentObserver; 30 import android.database.Cursor; 31 import android.database.MatrixCursor; 32 import android.database.sqlite.SQLiteDatabase; 33 import android.database.sqlite.SQLiteException; 34 import android.net.Uri; 35 import android.text.TextUtils; 36 import android.util.Log; 37 38 import com.android.email.Email; 39 import com.android.email.Preferences; 40 import com.android.email.provider.ContentCache.CacheToken; 41 import com.android.email.service.AttachmentDownloadService; 42 import com.android.emailcommon.Logging; 43 import com.android.emailcommon.provider.Account; 44 import com.android.emailcommon.provider.EmailContent; 45 import com.android.emailcommon.provider.EmailContent.AccountColumns; 46 import com.android.emailcommon.provider.EmailContent.Attachment; 47 import com.android.emailcommon.provider.EmailContent.AttachmentColumns; 48 import com.android.emailcommon.provider.EmailContent.Body; 49 import com.android.emailcommon.provider.EmailContent.BodyColumns; 50 import com.android.emailcommon.provider.EmailContent.MailboxColumns; 51 import com.android.emailcommon.provider.EmailContent.Message; 52 import com.android.emailcommon.provider.EmailContent.MessageColumns; 53 import com.android.emailcommon.provider.EmailContent.PolicyColumns; 54 import com.android.emailcommon.provider.HostAuth; 55 import com.android.emailcommon.provider.Mailbox; 56 import com.android.emailcommon.provider.Policy; 57 import com.android.emailcommon.provider.QuickResponse; 58 import com.google.common.annotations.VisibleForTesting; 59 60 import java.io.File; 61 import java.util.ArrayList; 62 import java.util.Arrays; 63 import java.util.Collection; 64 import java.util.HashMap; 65 import java.util.List; 66 import java.util.Map; 67 68 /** 69 * @author mblank 70 * 71 */ 72 public class EmailProvider extends ContentProvider { 73 74 private static final String TAG = "EmailProvider"; 75 76 public static final String EMAIL_APP_MIME_TYPE = "application/email-ls"; 77 78 protected static final String DATABASE_NAME = "EmailProvider.db"; 79 protected static final String BODY_DATABASE_NAME = "EmailProviderBody.db"; 80 protected static final String BACKUP_DATABASE_NAME = "EmailProviderBackup.db"; 81 82 public static final String ACTION_ATTACHMENT_UPDATED = "com.android.email.ATTACHMENT_UPDATED"; 83 public static final String ATTACHMENT_UPDATED_EXTRA_FLAGS = 84 "com.android.email.ATTACHMENT_UPDATED_FLAGS"; 85 86 /** 87 * Notifies that changes happened. Certain UI components, e.g., widgets, can register for this 88 * {@link android.content.Intent} and update accordingly. However, this can be very broad and 89 * is NOT the preferred way of getting notification. 90 */ 91 public static final String ACTION_NOTIFY_MESSAGE_LIST_DATASET_CHANGED = 92 "com.android.email.MESSAGE_LIST_DATASET_CHANGED"; 93 94 public static final String EMAIL_MESSAGE_MIME_TYPE = 95 "vnd.android.cursor.item/email-message"; 96 public static final String EMAIL_ATTACHMENT_MIME_TYPE = 97 "vnd.android.cursor.item/email-attachment"; 98 99 public static final Uri INTEGRITY_CHECK_URI = 100 Uri.parse("content://" + EmailContent.AUTHORITY + "/integrityCheck"); 101 public static final Uri ACCOUNT_BACKUP_URI = 102 Uri.parse("content://" + EmailContent.AUTHORITY + "/accountBackup"); 103 public static final Uri FOLDER_STATUS_URI = 104 Uri.parse("content://" + EmailContent.AUTHORITY + "/status"); 105 public static final Uri FOLDER_REFRESH_URI = 106 Uri.parse("content://" + EmailContent.AUTHORITY + "/refresh"); 107 108 /** Appended to the notification URI for delete operations */ 109 public static final String NOTIFICATION_OP_DELETE = "delete"; 110 /** Appended to the notification URI for insert operations */ 111 public static final String NOTIFICATION_OP_INSERT = "insert"; 112 /** Appended to the notification URI for update operations */ 113 public static final String NOTIFICATION_OP_UPDATE = "update"; 114 115 // Definitions for our queries looking for orphaned messages 116 private static final String[] ORPHANS_PROJECTION 117 = new String[] {MessageColumns.ID, MessageColumns.MAILBOX_KEY}; 118 private static final int ORPHANS_ID = 0; 119 private static final int ORPHANS_MAILBOX_KEY = 1; 120 121 private static final String WHERE_ID = EmailContent.RECORD_ID + "=?"; 122 123 // This is not a hard limit on accounts, per se, but beyond this, we can't guarantee that all 124 // critical mailboxes, host auth's, accounts, and policies are cached 125 private static final int MAX_CACHED_ACCOUNTS = 16; 126 // Inbox, Drafts, Sent, Outbox, Trash, and Search (these boxes are cached when possible) 127 private static final int NUM_ALWAYS_CACHED_MAILBOXES = 6; 128 129 // We'll cache the following four tables; sizes are best estimates of effective values 130 private final ContentCache mCacheAccount = 131 new ContentCache("Account", Account.CONTENT_PROJECTION, MAX_CACHED_ACCOUNTS); 132 private final ContentCache mCacheHostAuth = 133 new ContentCache("HostAuth", HostAuth.CONTENT_PROJECTION, MAX_CACHED_ACCOUNTS * 2); 134 /*package*/ final ContentCache mCacheMailbox = 135 new ContentCache("Mailbox", Mailbox.CONTENT_PROJECTION, 136 MAX_CACHED_ACCOUNTS * (NUM_ALWAYS_CACHED_MAILBOXES + 2)); 137 private final ContentCache mCacheMessage = 138 new ContentCache("Message", Message.CONTENT_PROJECTION, 8); 139 private final ContentCache mCachePolicy = 140 new ContentCache("Policy", Policy.CONTENT_PROJECTION, MAX_CACHED_ACCOUNTS); 141 142 private static final int ACCOUNT_BASE = 0; 143 private static final int ACCOUNT = ACCOUNT_BASE; 144 private static final int ACCOUNT_ID = ACCOUNT_BASE + 1; 145 private static final int ACCOUNT_ID_ADD_TO_FIELD = ACCOUNT_BASE + 2; 146 private static final int ACCOUNT_RESET_NEW_COUNT = ACCOUNT_BASE + 3; 147 private static final int ACCOUNT_RESET_NEW_COUNT_ID = ACCOUNT_BASE + 4; 148 private static final int ACCOUNT_DEFAULT_ID = ACCOUNT_BASE + 5; 149 150 private static final int MAILBOX_BASE = 0x1000; 151 private static final int MAILBOX = MAILBOX_BASE; 152 private static final int MAILBOX_ID = MAILBOX_BASE + 1; 153 private static final int MAILBOX_ID_FROM_ACCOUNT_AND_TYPE = MAILBOX_BASE + 2; 154 private static final int MAILBOX_ID_ADD_TO_FIELD = MAILBOX_BASE + 3; 155 private static final int MAILBOX_NOTIFICATION = MAILBOX_BASE + 4; 156 private static final int MAILBOX_MOST_RECENT_MESSAGE = MAILBOX_BASE + 5; 157 158 private static final int MESSAGE_BASE = 0x2000; 159 private static final int MESSAGE = MESSAGE_BASE; 160 private static final int MESSAGE_ID = MESSAGE_BASE + 1; 161 private static final int SYNCED_MESSAGE_ID = MESSAGE_BASE + 2; 162 163 private static final int ATTACHMENT_BASE = 0x3000; 164 private static final int ATTACHMENT = ATTACHMENT_BASE; 165 private static final int ATTACHMENT_ID = ATTACHMENT_BASE + 1; 166 private static final int ATTACHMENTS_MESSAGE_ID = ATTACHMENT_BASE + 2; 167 168 private static final int HOSTAUTH_BASE = 0x4000; 169 private static final int HOSTAUTH = HOSTAUTH_BASE; 170 private static final int HOSTAUTH_ID = HOSTAUTH_BASE + 1; 171 172 private static final int UPDATED_MESSAGE_BASE = 0x5000; 173 private static final int UPDATED_MESSAGE = UPDATED_MESSAGE_BASE; 174 private static final int UPDATED_MESSAGE_ID = UPDATED_MESSAGE_BASE + 1; 175 176 private static final int DELETED_MESSAGE_BASE = 0x6000; 177 private static final int DELETED_MESSAGE = DELETED_MESSAGE_BASE; 178 private static final int DELETED_MESSAGE_ID = DELETED_MESSAGE_BASE + 1; 179 180 private static final int POLICY_BASE = 0x7000; 181 private static final int POLICY = POLICY_BASE; 182 private static final int POLICY_ID = POLICY_BASE + 1; 183 184 private static final int QUICK_RESPONSE_BASE = 0x8000; 185 private static final int QUICK_RESPONSE = QUICK_RESPONSE_BASE; 186 private static final int QUICK_RESPONSE_ID = QUICK_RESPONSE_BASE + 1; 187 private static final int QUICK_RESPONSE_ACCOUNT_ID = QUICK_RESPONSE_BASE + 2; 188 189 private static final int UI_BASE = 0x9000; 190 private static final int UI_FOLDERS = UI_BASE; 191 private static final int UI_SUBFOLDERS = UI_BASE + 1; 192 private static final int UI_MESSAGES = UI_BASE + 2; 193 private static final int UI_MESSAGE = UI_BASE + 3; 194 private static final int UI_SENDMAIL = UI_BASE + 4; 195 private static final int UI_UNDO = UI_BASE + 5; 196 private static final int UI_SAVEDRAFT = UI_BASE + 6; 197 private static final int UI_UPDATEDRAFT = UI_BASE + 7; 198 private static final int UI_SENDDRAFT = UI_BASE + 8; 199 private static final int UI_FOLDER_REFRESH = UI_BASE + 9; 200 private static final int UI_FOLDER = UI_BASE + 10; 201 private static final int UI_ACCOUNT = UI_BASE + 11; 202 private static final int UI_ACCTS = UI_BASE + 12; 203 private static final int UI_ATTACHMENTS = UI_BASE + 13; 204 private static final int UI_ATTACHMENT = UI_BASE + 14; 205 private static final int UI_SEARCH = UI_BASE + 15; 206 private static final int UI_ACCOUNT_DATA = UI_BASE + 16; 207 private static final int UI_FOLDER_LOAD_MORE = UI_BASE + 17; 208 private static final int UI_CONVERSATION = UI_BASE + 18; 209 private static final int UI_RECENT_FOLDERS = UI_BASE + 19; 210 211 // MUST ALWAYS EQUAL THE LAST OF THE PREVIOUS BASE CONSTANTS 212 private static final int LAST_EMAIL_PROVIDER_DB_BASE = UI_BASE; 213 214 // DO NOT CHANGE BODY_BASE!! 215 private static final int BODY_BASE = LAST_EMAIL_PROVIDER_DB_BASE + 0x1000; 216 private static final int BODY = BODY_BASE; 217 private static final int BODY_ID = BODY_BASE + 1; 218 219 private static final int BASE_SHIFT = 12; // 12 bits to the base type: 0, 0x1000, 0x2000, etc. 220 221 // TABLE_NAMES MUST remain in the order of the BASE constants above (e.g. ACCOUNT_BASE = 0x0000, 222 // MESSAGE_BASE = 0x1000, etc.) 223 private static final String[] TABLE_NAMES = { 224 Account.TABLE_NAME, 225 Mailbox.TABLE_NAME, 226 Message.TABLE_NAME, 227 Attachment.TABLE_NAME, 228 HostAuth.TABLE_NAME, 229 Message.UPDATED_TABLE_NAME, 230 Message.DELETED_TABLE_NAME, 231 Policy.TABLE_NAME, 232 QuickResponse.TABLE_NAME, 233 null, // UI 234 Body.TABLE_NAME, 235 }; 236 237 // CONTENT_CACHES MUST remain in the order of the BASE constants above 238 private final ContentCache[] mContentCaches = { 239 mCacheAccount, 240 mCacheMailbox, 241 mCacheMessage, 242 null, // Attachment 243 mCacheHostAuth, 244 null, // Updated message 245 null, // Deleted message 246 mCachePolicy, 247 null, // Quick response 248 null, // Body 249 null // UI 250 }; 251 252 // CACHE_PROJECTIONS MUST remain in the order of the BASE constants above 253 private static final String[][] CACHE_PROJECTIONS = { 254 Account.CONTENT_PROJECTION, 255 Mailbox.CONTENT_PROJECTION, 256 Message.CONTENT_PROJECTION, 257 null, // Attachment 258 HostAuth.CONTENT_PROJECTION, 259 null, // Updated message 260 null, // Deleted message 261 Policy.CONTENT_PROJECTION, 262 null, // Quick response 263 null, // Body 264 null // UI 265 }; 266 267 private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH); 268 269 private static final String MAILBOX_PRE_CACHE_SELECTION = MailboxColumns.TYPE + " IN (" + 270 Mailbox.TYPE_INBOX + "," + Mailbox.TYPE_DRAFTS + "," + Mailbox.TYPE_TRASH + "," + 271 Mailbox.TYPE_SENT + "," + Mailbox.TYPE_SEARCH + "," + Mailbox.TYPE_OUTBOX + ")"; 272 273 /** 274 * Let's only generate these SQL strings once, as they are used frequently 275 * Note that this isn't relevant for table creation strings, since they are used only once 276 */ 277 private static final String UPDATED_MESSAGE_INSERT = "insert or ignore into " + 278 Message.UPDATED_TABLE_NAME + " select * from " + Message.TABLE_NAME + " where " + 279 EmailContent.RECORD_ID + '='; 280 281 private static final String UPDATED_MESSAGE_DELETE = "delete from " + 282 Message.UPDATED_TABLE_NAME + " where " + EmailContent.RECORD_ID + '='; 283 284 private static final String DELETED_MESSAGE_INSERT = "insert or replace into " + 285 Message.DELETED_TABLE_NAME + " select * from " + Message.TABLE_NAME + " where " + 286 EmailContent.RECORD_ID + '='; 287 288 private static final String DELETE_ORPHAN_BODIES = "delete from " + Body.TABLE_NAME + 289 " where " + BodyColumns.MESSAGE_KEY + " in " + "(select " + BodyColumns.MESSAGE_KEY + 290 " from " + Body.TABLE_NAME + " except select " + EmailContent.RECORD_ID + " from " + 291 Message.TABLE_NAME + ')'; 292 293 private static final String DELETE_BODY = "delete from " + Body.TABLE_NAME + 294 " where " + BodyColumns.MESSAGE_KEY + '='; 295 296 private static final String ID_EQUALS = EmailContent.RECORD_ID + "=?"; 297 298 private static final ContentValues CONTENT_VALUES_RESET_NEW_MESSAGE_COUNT; 299 300 public static final String MESSAGE_URI_PARAMETER_MAILBOX_ID = "mailboxId"; 301 302 static { 303 // Email URI matching table 304 UriMatcher matcher = sURIMatcher; 305 306 // All accounts 307 matcher.addURI(EmailContent.AUTHORITY, "account", ACCOUNT); 308 // A specific account 309 // insert into this URI causes a mailbox to be added to the account 310 matcher.addURI(EmailContent.AUTHORITY, "account/#", ACCOUNT_ID); 311 matcher.addURI(EmailContent.AUTHORITY, "account/default", ACCOUNT_DEFAULT_ID); 312 313 // Special URI to reset the new message count. Only update works, and content values 314 // will be ignored. 315 matcher.addURI(EmailContent.AUTHORITY, "resetNewMessageCount", 316 ACCOUNT_RESET_NEW_COUNT); 317 matcher.addURI(EmailContent.AUTHORITY, "resetNewMessageCount/#", 318 ACCOUNT_RESET_NEW_COUNT_ID); 319 320 // All mailboxes 321 matcher.addURI(EmailContent.AUTHORITY, "mailbox", MAILBOX); 322 // A specific mailbox 323 // insert into this URI causes a message to be added to the mailbox 324 // ** NOTE For now, the accountKey must be set manually in the values! 325 matcher.addURI(EmailContent.AUTHORITY, "mailbox/#", MAILBOX_ID); 326 matcher.addURI(EmailContent.AUTHORITY, "mailboxIdFromAccountAndType/#/#", 327 MAILBOX_ID_FROM_ACCOUNT_AND_TYPE); 328 matcher.addURI(EmailContent.AUTHORITY, "mailboxNotification/#", MAILBOX_NOTIFICATION); 329 matcher.addURI(EmailContent.AUTHORITY, "mailboxMostRecentMessage/#", 330 MAILBOX_MOST_RECENT_MESSAGE); 331 332 // All messages 333 matcher.addURI(EmailContent.AUTHORITY, "message", MESSAGE); 334 // A specific message 335 // insert into this URI causes an attachment to be added to the message 336 matcher.addURI(EmailContent.AUTHORITY, "message/#", MESSAGE_ID); 337 338 // A specific attachment 339 matcher.addURI(EmailContent.AUTHORITY, "attachment", ATTACHMENT); 340 // A specific attachment (the header information) 341 matcher.addURI(EmailContent.AUTHORITY, "attachment/#", ATTACHMENT_ID); 342 // The attachments of a specific message (query only) (insert & delete TBD) 343 matcher.addURI(EmailContent.AUTHORITY, "attachment/message/#", 344 ATTACHMENTS_MESSAGE_ID); 345 346 // All mail bodies 347 matcher.addURI(EmailContent.AUTHORITY, "body", BODY); 348 // A specific mail body 349 matcher.addURI(EmailContent.AUTHORITY, "body/#", BODY_ID); 350 351 // All hostauth records 352 matcher.addURI(EmailContent.AUTHORITY, "hostauth", HOSTAUTH); 353 // A specific hostauth 354 matcher.addURI(EmailContent.AUTHORITY, "hostauth/#", HOSTAUTH_ID); 355 356 // Atomically a constant value to a particular field of a mailbox/account 357 matcher.addURI(EmailContent.AUTHORITY, "mailboxIdAddToField/#", 358 MAILBOX_ID_ADD_TO_FIELD); 359 matcher.addURI(EmailContent.AUTHORITY, "accountIdAddToField/#", 360 ACCOUNT_ID_ADD_TO_FIELD); 361 362 /** 363 * THIS URI HAS SPECIAL SEMANTICS 364 * ITS USE IS INTENDED FOR THE UI APPLICATION TO MARK CHANGES THAT NEED TO BE SYNCED BACK 365 * TO A SERVER VIA A SYNC ADAPTER 366 */ 367 matcher.addURI(EmailContent.AUTHORITY, "syncedMessage/#", SYNCED_MESSAGE_ID); 368 369 /** 370 * THE URIs BELOW THIS POINT ARE INTENDED TO BE USED BY SYNC ADAPTERS ONLY 371 * THEY REFER TO DATA CREATED AND MAINTAINED BY CALLS TO THE SYNCED_MESSAGE_ID URI 372 * BY THE UI APPLICATION 373 */ 374 // All deleted messages 375 matcher.addURI(EmailContent.AUTHORITY, "deletedMessage", DELETED_MESSAGE); 376 // A specific deleted message 377 matcher.addURI(EmailContent.AUTHORITY, "deletedMessage/#", DELETED_MESSAGE_ID); 378 379 // All updated messages 380 matcher.addURI(EmailContent.AUTHORITY, "updatedMessage", UPDATED_MESSAGE); 381 // A specific updated message 382 matcher.addURI(EmailContent.AUTHORITY, "updatedMessage/#", UPDATED_MESSAGE_ID); 383 384 CONTENT_VALUES_RESET_NEW_MESSAGE_COUNT = new ContentValues(); 385 CONTENT_VALUES_RESET_NEW_MESSAGE_COUNT.put(Account.NEW_MESSAGE_COUNT, 0); 386 387 matcher.addURI(EmailContent.AUTHORITY, "policy", POLICY); 388 matcher.addURI(EmailContent.AUTHORITY, "policy/#", POLICY_ID); 389 390 // All quick responses 391 matcher.addURI(EmailContent.AUTHORITY, "quickresponse", QUICK_RESPONSE); 392 // A specific quick response 393 matcher.addURI(EmailContent.AUTHORITY, "quickresponse/#", QUICK_RESPONSE_ID); 394 // All quick responses associated with a particular account id 395 matcher.addURI(EmailContent.AUTHORITY, "quickresponse/account/#", 396 QUICK_RESPONSE_ACCOUNT_ID); 397 398 matcher.addURI(EmailContent.AUTHORITY, "uifolders/#", UI_FOLDERS); 399 matcher.addURI(EmailContent.AUTHORITY, "uisubfolders/#", UI_SUBFOLDERS); 400 matcher.addURI(EmailContent.AUTHORITY, "uimessages/#", UI_MESSAGES); 401 matcher.addURI(EmailContent.AUTHORITY, "uimessage/#", UI_MESSAGE); 402 matcher.addURI(EmailContent.AUTHORITY, "uisendmail/#", UI_SENDMAIL); 403 matcher.addURI(EmailContent.AUTHORITY, "uiundo", UI_UNDO); 404 matcher.addURI(EmailContent.AUTHORITY, "uisavedraft/#", UI_SAVEDRAFT); 405 matcher.addURI(EmailContent.AUTHORITY, "uiupdatedraft/#", UI_UPDATEDRAFT); 406 matcher.addURI(EmailContent.AUTHORITY, "uisenddraft/#", UI_SENDDRAFT); 407 matcher.addURI(EmailContent.AUTHORITY, "uirefresh/#", UI_FOLDER_REFRESH); 408 matcher.addURI(EmailContent.AUTHORITY, "uifolder/#", UI_FOLDER); 409 matcher.addURI(EmailContent.AUTHORITY, "uiaccount/#", UI_ACCOUNT); 410 matcher.addURI(EmailContent.AUTHORITY, "uiaccts", UI_ACCTS); 411 matcher.addURI(EmailContent.AUTHORITY, "uiattachments/#", UI_ATTACHMENTS); 412 matcher.addURI(EmailContent.AUTHORITY, "uiattachment/#", UI_ATTACHMENT); 413 matcher.addURI(EmailContent.AUTHORITY, "uisearch/#", UI_SEARCH); 414 matcher.addURI(EmailContent.AUTHORITY, "uiaccountdata/#", UI_ACCOUNT_DATA); 415 matcher.addURI(EmailContent.AUTHORITY, "uiloadmore/#", UI_FOLDER_LOAD_MORE); 416 matcher.addURI(EmailContent.AUTHORITY, "uiconversation/#", UI_CONVERSATION); 417 matcher.addURI(EmailContent.AUTHORITY, "uirecentfolders/#", UI_RECENT_FOLDERS); 418 } 419 420 /** 421 * Wrap the UriMatcher call so we can throw a runtime exception if an unknown Uri is passed in 422 * @param uri the Uri to match 423 * @return the match value 424 */ 425 private static int findMatch(Uri uri, String methodName) { 426 int match = sURIMatcher.match(uri); 427 if (match < 0) { 428 throw new IllegalArgumentException("Unknown uri: " + uri); 429 } else if (Logging.LOGD) { 430 Log.v(TAG, methodName + ": uri=" + uri + ", match is " + match); 431 } 432 return match; 433 } 434 435 private SQLiteDatabase mDatabase; 436 private SQLiteDatabase mBodyDatabase; 437 438 public static Uri uiUri(String type, long id) { 439 return Uri.parse(uiUriString(type, id)); 440 } 441 442 public static String uiUriString(String type, long id) { 443 return "content://" + EmailContent.AUTHORITY + "/" + type + ((id == -1) ? "" : ("/" + id)); 444 } 445 446 /** 447 * Orphan record deletion utility. Generates a sqlite statement like: 448 * delete from <table> where <column> not in (select <foreignColumn> from <foreignTable>) 449 * @param db the EmailProvider database 450 * @param table the table whose orphans are to be removed 451 * @param column the column deletion will be based on 452 * @param foreignColumn the column in the foreign table whose absence will trigger the deletion 453 * @param foreignTable the foreign table 454 */ 455 @VisibleForTesting 456 void deleteUnlinked(SQLiteDatabase db, String table, String column, String foreignColumn, 457 String foreignTable) { 458 int count = db.delete(table, column + " not in (select " + foreignColumn + " from " + 459 foreignTable + ")", null); 460 if (count > 0) { 461 Log.w(TAG, "Found " + count + " orphaned row(s) in " + table); 462 } 463 } 464 465 @VisibleForTesting 466 synchronized SQLiteDatabase getDatabase(Context context) { 467 // Always return the cached database, if we've got one 468 if (mDatabase != null) { 469 return mDatabase; 470 } 471 472 // Whenever we create or re-cache the databases, make sure that we haven't lost one 473 // to corruption 474 checkDatabases(); 475 476 DBHelper.DatabaseHelper helper = new DBHelper.DatabaseHelper(context, DATABASE_NAME); 477 mDatabase = helper.getWritableDatabase(); 478 DBHelper.BodyDatabaseHelper bodyHelper = 479 new DBHelper.BodyDatabaseHelper(context, BODY_DATABASE_NAME); 480 mBodyDatabase = bodyHelper.getWritableDatabase(); 481 if (mBodyDatabase != null) { 482 String bodyFileName = mBodyDatabase.getPath(); 483 mDatabase.execSQL("attach \"" + bodyFileName + "\" as BodyDatabase"); 484 } 485 486 // Restore accounts if the database is corrupted... 487 restoreIfNeeded(context, mDatabase); 488 // Check for any orphaned Messages in the updated/deleted tables 489 deleteMessageOrphans(mDatabase, Message.UPDATED_TABLE_NAME); 490 deleteMessageOrphans(mDatabase, Message.DELETED_TABLE_NAME); 491 // Delete orphaned mailboxes/messages/policies (account no longer exists) 492 deleteUnlinked(mDatabase, Mailbox.TABLE_NAME, MailboxColumns.ACCOUNT_KEY, AccountColumns.ID, 493 Account.TABLE_NAME); 494 deleteUnlinked(mDatabase, Message.TABLE_NAME, MessageColumns.ACCOUNT_KEY, AccountColumns.ID, 495 Account.TABLE_NAME); 496 deleteUnlinked(mDatabase, Policy.TABLE_NAME, PolicyColumns.ID, AccountColumns.POLICY_KEY, 497 Account.TABLE_NAME); 498 preCacheData(); 499 return mDatabase; 500 } 501 502 /** 503 * Pre-cache all of the items in a given table meeting the selection criteria 504 * @param tableUri the table uri 505 * @param baseProjection the base projection of that table 506 * @param selection the selection criteria 507 */ 508 private void preCacheTable(Uri tableUri, String[] baseProjection, String selection) { 509 Cursor c = query(tableUri, EmailContent.ID_PROJECTION, selection, null, null); 510 try { 511 while (c.moveToNext()) { 512 long id = c.getLong(EmailContent.ID_PROJECTION_COLUMN); 513 Cursor cachedCursor = query(ContentUris.withAppendedId( 514 tableUri, id), baseProjection, null, null, null); 515 if (cachedCursor != null) { 516 // For accounts, create a mailbox type map entry (if necessary) 517 if (tableUri == Account.CONTENT_URI) { 518 getOrCreateAccountMailboxTypeMap(id); 519 } 520 cachedCursor.close(); 521 } 522 } 523 } finally { 524 c.close(); 525 } 526 } 527 528 private final HashMap<Long, HashMap<Integer, Long>> mMailboxTypeMap = 529 new HashMap<Long, HashMap<Integer, Long>>(); 530 531 private HashMap<Integer, Long> getOrCreateAccountMailboxTypeMap(long accountId) { 532 synchronized(mMailboxTypeMap) { 533 HashMap<Integer, Long> accountMailboxTypeMap = mMailboxTypeMap.get(accountId); 534 if (accountMailboxTypeMap == null) { 535 accountMailboxTypeMap = new HashMap<Integer, Long>(); 536 mMailboxTypeMap.put(accountId, accountMailboxTypeMap); 537 } 538 return accountMailboxTypeMap; 539 } 540 } 541 542 private void addToMailboxTypeMap(Cursor c) { 543 long accountId = c.getLong(Mailbox.CONTENT_ACCOUNT_KEY_COLUMN); 544 int type = c.getInt(Mailbox.CONTENT_TYPE_COLUMN); 545 synchronized(mMailboxTypeMap) { 546 HashMap<Integer, Long> accountMailboxTypeMap = 547 getOrCreateAccountMailboxTypeMap(accountId); 548 accountMailboxTypeMap.put(type, c.getLong(Mailbox.CONTENT_ID_COLUMN)); 549 } 550 } 551 552 private long getMailboxIdFromMailboxTypeMap(long accountId, int type) { 553 synchronized(mMailboxTypeMap) { 554 HashMap<Integer, Long> accountMap = mMailboxTypeMap.get(accountId); 555 Long mailboxId = null; 556 if (accountMap != null) { 557 mailboxId = accountMap.get(type); 558 } 559 if (mailboxId == null) return Mailbox.NO_MAILBOX; 560 return mailboxId; 561 } 562 } 563 564 private void preCacheData() { 565 synchronized(mMailboxTypeMap) { 566 mMailboxTypeMap.clear(); 567 568 // Pre-cache accounts, host auth's, policies, and special mailboxes 569 preCacheTable(Account.CONTENT_URI, Account.CONTENT_PROJECTION, null); 570 preCacheTable(HostAuth.CONTENT_URI, HostAuth.CONTENT_PROJECTION, null); 571 preCacheTable(Policy.CONTENT_URI, Policy.CONTENT_PROJECTION, null); 572 preCacheTable(Mailbox.CONTENT_URI, Mailbox.CONTENT_PROJECTION, 573 MAILBOX_PRE_CACHE_SELECTION); 574 575 // Create a map from account,type to a mailbox 576 Map<String, Cursor> snapshot = mCacheMailbox.getSnapshot(); 577 Collection<Cursor> values = snapshot.values(); 578 if (values != null) { 579 for (Cursor c: values) { 580 if (c.moveToFirst()) { 581 addToMailboxTypeMap(c); 582 } 583 } 584 } 585 } 586 } 587 588 /*package*/ static SQLiteDatabase getReadableDatabase(Context context) { 589 DBHelper.DatabaseHelper helper = new DBHelper.DatabaseHelper(context, DATABASE_NAME); 590 return helper.getReadableDatabase(); 591 } 592 593 /** 594 * Restore user Account and HostAuth data from our backup database 595 */ 596 public static void restoreIfNeeded(Context context, SQLiteDatabase mainDatabase) { 597 if (Email.DEBUG) { 598 Log.w(TAG, "restoreIfNeeded..."); 599 } 600 // Check for legacy backup 601 String legacyBackup = Preferences.getLegacyBackupPreference(context); 602 // If there's a legacy backup, create a new-style backup and delete the legacy backup 603 // In the 1:1000000000 chance that the user gets an app update just as his database becomes 604 // corrupt, oh well... 605 if (!TextUtils.isEmpty(legacyBackup)) { 606 backupAccounts(context, mainDatabase); 607 Preferences.clearLegacyBackupPreference(context); 608 Log.w(TAG, "Created new EmailProvider backup database"); 609 return; 610 } 611 612 // If we have accounts, we're done 613 Cursor c = mainDatabase.query(Account.TABLE_NAME, EmailContent.ID_PROJECTION, null, null, 614 null, null, null); 615 try { 616 if (c.moveToFirst()) { 617 if (Email.DEBUG) { 618 Log.w(TAG, "restoreIfNeeded: Account exists."); 619 } 620 return; // At least one account exists. 621 } 622 } finally { 623 c.close(); 624 } 625 626 restoreAccounts(context, mainDatabase); 627 } 628 629 /** {@inheritDoc} */ 630 @Override 631 public void shutdown() { 632 if (mDatabase != null) { 633 mDatabase.close(); 634 mDatabase = null; 635 } 636 if (mBodyDatabase != null) { 637 mBodyDatabase.close(); 638 mBodyDatabase = null; 639 } 640 } 641 642 /*package*/ static void deleteMessageOrphans(SQLiteDatabase database, String tableName) { 643 if (database != null) { 644 // We'll look at all of the items in the table; there won't be many typically 645 Cursor c = database.query(tableName, ORPHANS_PROJECTION, null, null, null, null, null); 646 // Usually, there will be nothing in these tables, so make a quick check 647 try { 648 if (c.getCount() == 0) return; 649 ArrayList<Long> foundMailboxes = new ArrayList<Long>(); 650 ArrayList<Long> notFoundMailboxes = new ArrayList<Long>(); 651 ArrayList<Long> deleteList = new ArrayList<Long>(); 652 String[] bindArray = new String[1]; 653 while (c.moveToNext()) { 654 // Get the mailbox key and see if we've already found this mailbox 655 // If so, we're fine 656 long mailboxId = c.getLong(ORPHANS_MAILBOX_KEY); 657 // If we already know this mailbox doesn't exist, mark the message for deletion 658 if (notFoundMailboxes.contains(mailboxId)) { 659 deleteList.add(c.getLong(ORPHANS_ID)); 660 // If we don't know about this mailbox, we'll try to find it 661 } else if (!foundMailboxes.contains(mailboxId)) { 662 bindArray[0] = Long.toString(mailboxId); 663 Cursor boxCursor = database.query(Mailbox.TABLE_NAME, 664 Mailbox.ID_PROJECTION, WHERE_ID, bindArray, null, null, null); 665 try { 666 // If it exists, we'll add it to the "found" mailboxes 667 if (boxCursor.moveToFirst()) { 668 foundMailboxes.add(mailboxId); 669 // Otherwise, we'll add to "not found" and mark the message for deletion 670 } else { 671 notFoundMailboxes.add(mailboxId); 672 deleteList.add(c.getLong(ORPHANS_ID)); 673 } 674 } finally { 675 boxCursor.close(); 676 } 677 } 678 } 679 // Now, delete the orphan messages 680 for (long messageId: deleteList) { 681 bindArray[0] = Long.toString(messageId); 682 database.delete(tableName, WHERE_ID, bindArray); 683 } 684 } finally { 685 c.close(); 686 } 687 } 688 } 689 690 @Override 691 public int delete(Uri uri, String selection, String[] selectionArgs) { 692 final int match = findMatch(uri, "delete"); 693 Context context = getContext(); 694 // Pick the correct database for this operation 695 // If we're in a transaction already (which would happen during applyBatch), then the 696 // body database is already attached to the email database and any attempt to use the 697 // body database directly will result in a SQLiteException (the database is locked) 698 SQLiteDatabase db = getDatabase(context); 699 int table = match >> BASE_SHIFT; 700 String id = "0"; 701 boolean messageDeletion = false; 702 ContentResolver resolver = context.getContentResolver(); 703 704 ContentCache cache = mContentCaches[table]; 705 String tableName = TABLE_NAMES[table]; 706 int result = -1; 707 708 try { 709 switch (match) { 710 case UI_MESSAGE: 711 // These are cases in which one or more Messages might get deleted, either by 712 // cascade or explicitly 713 case MAILBOX_ID: 714 case MAILBOX: 715 case ACCOUNT_ID: 716 case ACCOUNT: 717 case MESSAGE: 718 case SYNCED_MESSAGE_ID: 719 case MESSAGE_ID: 720 // Handle lost Body records here, since this cannot be done in a trigger 721 // The process is: 722 // 1) Begin a transaction, ensuring that both databases are affected atomically 723 // 2) Do the requested deletion, with cascading deletions handled in triggers 724 // 3) End the transaction, committing all changes atomically 725 // 726 // Bodies are auto-deleted here; Attachments are auto-deleted via trigger 727 messageDeletion = true; 728 db.beginTransaction(); 729 break; 730 } 731 switch (match) { 732 case BODY_ID: 733 case DELETED_MESSAGE_ID: 734 case SYNCED_MESSAGE_ID: 735 case MESSAGE_ID: 736 case UPDATED_MESSAGE_ID: 737 case ATTACHMENT_ID: 738 case MAILBOX_ID: 739 case ACCOUNT_ID: 740 case HOSTAUTH_ID: 741 case POLICY_ID: 742 case QUICK_RESPONSE_ID: 743 id = uri.getPathSegments().get(1); 744 if (match == SYNCED_MESSAGE_ID) { 745 // For synced messages, first copy the old message to the deleted table and 746 // delete it from the updated table (in case it was updated first) 747 // Note that this is all within a transaction, for atomicity 748 db.execSQL(DELETED_MESSAGE_INSERT + id); 749 db.execSQL(UPDATED_MESSAGE_DELETE + id); 750 } 751 if (cache != null) { 752 cache.lock(id); 753 } 754 try { 755 result = db.delete(tableName, whereWithId(id, selection), selectionArgs); 756 if (cache != null) { 757 switch(match) { 758 case ACCOUNT_ID: 759 // Account deletion will clear all of the caches, as HostAuth's, 760 // Mailboxes, and Messages will be deleted in the process 761 mCacheMailbox.invalidate("Delete", uri, selection); 762 mCacheHostAuth.invalidate("Delete", uri, selection); 763 mCachePolicy.invalidate("Delete", uri, selection); 764 //$FALL-THROUGH$ 765 case MAILBOX_ID: 766 // Mailbox deletion will clear the Message cache 767 mCacheMessage.invalidate("Delete", uri, selection); 768 //$FALL-THROUGH$ 769 case SYNCED_MESSAGE_ID: 770 case MESSAGE_ID: 771 case HOSTAUTH_ID: 772 case POLICY_ID: 773 cache.invalidate("Delete", uri, selection); 774 // Make sure all data is properly cached 775 if (match != MESSAGE_ID) { 776 preCacheData(); 777 } 778 break; 779 } 780 } 781 } finally { 782 if (cache != null) { 783 cache.unlock(id); 784 } 785 } 786 break; 787 case ATTACHMENTS_MESSAGE_ID: 788 // All attachments for the given message 789 id = uri.getPathSegments().get(2); 790 result = db.delete(tableName, 791 whereWith(Attachment.MESSAGE_KEY + "=" + id, selection), selectionArgs); 792 break; 793 794 case BODY: 795 case MESSAGE: 796 case DELETED_MESSAGE: 797 case UPDATED_MESSAGE: 798 case ATTACHMENT: 799 case MAILBOX: 800 case ACCOUNT: 801 case HOSTAUTH: 802 case POLICY: 803 switch(match) { 804 // See the comments above for deletion of ACCOUNT_ID, etc 805 case ACCOUNT: 806 mCacheMailbox.invalidate("Delete", uri, selection); 807 mCacheHostAuth.invalidate("Delete", uri, selection); 808 mCachePolicy.invalidate("Delete", uri, selection); 809 //$FALL-THROUGH$ 810 case MAILBOX: 811 mCacheMessage.invalidate("Delete", uri, selection); 812 //$FALL-THROUGH$ 813 case MESSAGE: 814 case HOSTAUTH: 815 case POLICY: 816 cache.invalidate("Delete", uri, selection); 817 break; 818 } 819 result = db.delete(tableName, selection, selectionArgs); 820 switch(match) { 821 case ACCOUNT: 822 case MAILBOX: 823 case HOSTAUTH: 824 case POLICY: 825 // Make sure all data is properly cached 826 preCacheData(); 827 break; 828 } 829 break; 830 831 default: 832 throw new IllegalArgumentException("Unknown URI " + uri); 833 } 834 if (messageDeletion) { 835 if (match == MESSAGE_ID) { 836 // Delete the Body record associated with the deleted message 837 db.execSQL(DELETE_BODY + id); 838 } else { 839 // Delete any orphaned Body records 840 db.execSQL(DELETE_ORPHAN_BODIES); 841 } 842 db.setTransactionSuccessful(); 843 } 844 } catch (SQLiteException e) { 845 checkDatabases(); 846 throw e; 847 } finally { 848 if (messageDeletion) { 849 db.endTransaction(); 850 } 851 } 852 853 // Notify all notifier cursors 854 sendNotifierChange(getBaseNotificationUri(match), NOTIFICATION_OP_DELETE, id); 855 856 // Notify all email content cursors 857 resolver.notifyChange(EmailContent.CONTENT_URI, null); 858 return result; 859 } 860 861 @Override 862 // Use the email- prefix because message, mailbox, and account are so generic (e.g. SMS, IM) 863 public String getType(Uri uri) { 864 int match = findMatch(uri, "getType"); 865 switch (match) { 866 case BODY_ID: 867 return "vnd.android.cursor.item/email-body"; 868 case BODY: 869 return "vnd.android.cursor.dir/email-body"; 870 case UPDATED_MESSAGE_ID: 871 case MESSAGE_ID: 872 // NOTE: According to the framework folks, we're supposed to invent mime types as 873 // a way of passing information to drag & drop recipients. 874 // If there's a mailboxId parameter in the url, we respond with a mime type that 875 // has -n appended, where n is the mailboxId of the message. The drag & drop code 876 // uses this information to know not to allow dragging the item to its own mailbox 877 String mimeType = EMAIL_MESSAGE_MIME_TYPE; 878 String mailboxId = uri.getQueryParameter(MESSAGE_URI_PARAMETER_MAILBOX_ID); 879 if (mailboxId != null) { 880 mimeType += "-" + mailboxId; 881 } 882 return mimeType; 883 case UPDATED_MESSAGE: 884 case MESSAGE: 885 return "vnd.android.cursor.dir/email-message"; 886 case MAILBOX: 887 return "vnd.android.cursor.dir/email-mailbox"; 888 case MAILBOX_ID: 889 return "vnd.android.cursor.item/email-mailbox"; 890 case ACCOUNT: 891 return "vnd.android.cursor.dir/email-account"; 892 case ACCOUNT_ID: 893 return "vnd.android.cursor.item/email-account"; 894 case ATTACHMENTS_MESSAGE_ID: 895 case ATTACHMENT: 896 return "vnd.android.cursor.dir/email-attachment"; 897 case ATTACHMENT_ID: 898 return EMAIL_ATTACHMENT_MIME_TYPE; 899 case HOSTAUTH: 900 return "vnd.android.cursor.dir/email-hostauth"; 901 case HOSTAUTH_ID: 902 return "vnd.android.cursor.item/email-hostauth"; 903 default: 904 throw new IllegalArgumentException("Unknown URI " + uri); 905 } 906 } 907 908 @Override 909 public Uri insert(Uri uri, ContentValues values) { 910 int match = findMatch(uri, "insert"); 911 Context context = getContext(); 912 ContentResolver resolver = context.getContentResolver(); 913 914 // See the comment at delete(), above 915 SQLiteDatabase db = getDatabase(context); 916 int table = match >> BASE_SHIFT; 917 String id = "0"; 918 long longId; 919 920 // We do NOT allow setting of unreadCount/messageCount via the provider 921 // These columns are maintained via triggers 922 if (match == MAILBOX_ID || match == MAILBOX) { 923 values.put(MailboxColumns.UNREAD_COUNT, 0); 924 values.put(MailboxColumns.MESSAGE_COUNT, 0); 925 } 926 927 Uri resultUri = null; 928 929 try { 930 switch (match) { 931 // NOTE: It is NOT legal for production code to insert directly into UPDATED_MESSAGE 932 // or DELETED_MESSAGE; see the comment below for details 933 case UPDATED_MESSAGE: 934 case DELETED_MESSAGE: 935 case MESSAGE: 936 case BODY: 937 case ATTACHMENT: 938 case MAILBOX: 939 case ACCOUNT: 940 case HOSTAUTH: 941 case POLICY: 942 case QUICK_RESPONSE: 943 longId = db.insert(TABLE_NAMES[table], "foo", values); 944 resultUri = ContentUris.withAppendedId(uri, longId); 945 switch(match) { 946 case MAILBOX: 947 if (values.containsKey(MailboxColumns.TYPE)) { 948 // Only cache special mailbox types 949 int type = values.getAsInteger(MailboxColumns.TYPE); 950 if (type != Mailbox.TYPE_INBOX && type != Mailbox.TYPE_OUTBOX && 951 type != Mailbox.TYPE_DRAFTS && type != Mailbox.TYPE_SENT && 952 type != Mailbox.TYPE_TRASH && type != Mailbox.TYPE_SEARCH) { 953 break; 954 } 955 } 956 //$FALL-THROUGH$ 957 case ACCOUNT: 958 case HOSTAUTH: 959 case POLICY: 960 // Cache new account, host auth, policy, and some mailbox rows 961 Cursor c = query(resultUri, CACHE_PROJECTIONS[table], null, null, null); 962 if (c != null) { 963 if (match == MAILBOX) { 964 addToMailboxTypeMap(c); 965 } else if (match == ACCOUNT) { 966 getOrCreateAccountMailboxTypeMap(longId); 967 } 968 c.close(); 969 } 970 break; 971 } 972 // Clients shouldn't normally be adding rows to these tables, as they are 973 // maintained by triggers. However, we need to be able to do this for unit 974 // testing, so we allow the insert and then throw the same exception that we 975 // would if this weren't allowed. 976 if (match == UPDATED_MESSAGE || match == DELETED_MESSAGE) { 977 throw new IllegalArgumentException("Unknown URL " + uri); 978 } else if (match == ATTACHMENT) { 979 int flags = 0; 980 if (values.containsKey(Attachment.FLAGS)) { 981 flags = values.getAsInteger(Attachment.FLAGS); 982 } 983 // Report all new attachments to the download service 984 mAttachmentService.attachmentChanged(getContext(), longId, flags); 985 } 986 break; 987 case MAILBOX_ID: 988 // This implies adding a message to a mailbox 989 // Hmm, a problem here is that we can't link the account as well, so it must be 990 // already in the values... 991 longId = Long.parseLong(uri.getPathSegments().get(1)); 992 values.put(MessageColumns.MAILBOX_KEY, longId); 993 return insert(Message.CONTENT_URI, values); // Recurse 994 case MESSAGE_ID: 995 // This implies adding an attachment to a message. 996 id = uri.getPathSegments().get(1); 997 longId = Long.parseLong(id); 998 values.put(AttachmentColumns.MESSAGE_KEY, longId); 999 return insert(Attachment.CONTENT_URI, values); // Recurse 1000 case ACCOUNT_ID: 1001 // This implies adding a mailbox to an account. 1002 longId = Long.parseLong(uri.getPathSegments().get(1)); 1003 values.put(MailboxColumns.ACCOUNT_KEY, longId); 1004 return insert(Mailbox.CONTENT_URI, values); // Recurse 1005 case ATTACHMENTS_MESSAGE_ID: 1006 longId = db.insert(TABLE_NAMES[table], "foo", values); 1007 resultUri = ContentUris.withAppendedId(Attachment.CONTENT_URI, longId); 1008 break; 1009 default: 1010 throw new IllegalArgumentException("Unknown URL " + uri); 1011 } 1012 } catch (SQLiteException e) { 1013 checkDatabases(); 1014 throw e; 1015 } 1016 1017 // Notify all notifier cursors 1018 sendNotifierChange(getBaseNotificationUri(match), NOTIFICATION_OP_INSERT, id); 1019 1020 // Notify all existing cursors. 1021 resolver.notifyChange(EmailContent.CONTENT_URI, null); 1022 return resultUri; 1023 } 1024 1025 @Override 1026 public boolean onCreate() { 1027 Email.setServicesEnabledAsync(getContext()); 1028 checkDatabases(); 1029 return false; 1030 } 1031 1032 /** 1033 * The idea here is that the two databases (EmailProvider.db and EmailProviderBody.db must 1034 * always be in sync (i.e. there are two database or NO databases). This code will delete 1035 * any "orphan" database, so that both will be created together. Note that an "orphan" database 1036 * will exist after either of the individual databases is deleted due to data corruption. 1037 */ 1038 public synchronized void checkDatabases() { 1039 // Uncache the databases 1040 if (mDatabase != null) { 1041 mDatabase = null; 1042 } 1043 if (mBodyDatabase != null) { 1044 mBodyDatabase = null; 1045 } 1046 // Look for orphans, and delete as necessary; these must always be in sync 1047 File databaseFile = getContext().getDatabasePath(DATABASE_NAME); 1048 File bodyFile = getContext().getDatabasePath(BODY_DATABASE_NAME); 1049 1050 // TODO Make sure attachments are deleted 1051 if (databaseFile.exists() && !bodyFile.exists()) { 1052 Log.w(TAG, "Deleting orphaned EmailProvider database..."); 1053 databaseFile.delete(); 1054 } else if (bodyFile.exists() && !databaseFile.exists()) { 1055 Log.w(TAG, "Deleting orphaned EmailProviderBody database..."); 1056 bodyFile.delete(); 1057 } 1058 } 1059 @Override 1060 public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, 1061 String sortOrder) { 1062 long time = 0L; 1063 if (Email.DEBUG) { 1064 time = System.nanoTime(); 1065 } 1066 Cursor c = null; 1067 int match; 1068 try { 1069 match = findMatch(uri, "query"); 1070 } catch (IllegalArgumentException e) { 1071 String uriString = uri.toString(); 1072 // If we were passed an illegal uri, see if it ends in /-1 1073 // if so, and if substituting 0 for -1 results in a valid uri, return an empty cursor 1074 if (uriString != null && uriString.endsWith("/-1")) { 1075 uri = Uri.parse(uriString.substring(0, uriString.length() - 2) + "0"); 1076 match = findMatch(uri, "query"); 1077 switch (match) { 1078 case BODY_ID: 1079 case MESSAGE_ID: 1080 case DELETED_MESSAGE_ID: 1081 case UPDATED_MESSAGE_ID: 1082 case ATTACHMENT_ID: 1083 case MAILBOX_ID: 1084 case ACCOUNT_ID: 1085 case HOSTAUTH_ID: 1086 case POLICY_ID: 1087 return new MatrixCursor(projection, 0); 1088 } 1089 } 1090 throw e; 1091 } 1092 Context context = getContext(); 1093 // See the comment at delete(), above 1094 SQLiteDatabase db = getDatabase(context); 1095 int table = match >> BASE_SHIFT; 1096 String limit = uri.getQueryParameter(EmailContent.PARAMETER_LIMIT); 1097 String id; 1098 1099 // Find the cache for this query's table (if any) 1100 ContentCache cache = null; 1101 String tableName = TABLE_NAMES[table]; 1102 // We can only use the cache if there's no selection 1103 if (selection == null) { 1104 cache = mContentCaches[table]; 1105 } 1106 if (cache == null) { 1107 ContentCache.notCacheable(uri, selection); 1108 } 1109 1110 try { 1111 switch (match) { 1112 case MAILBOX_NOTIFICATION: 1113 c = notificationQuery(uri); 1114 return c; 1115 case MAILBOX_MOST_RECENT_MESSAGE: 1116 c = mostRecentMessageQuery(uri); 1117 return c; 1118 case ACCOUNT_DEFAULT_ID: 1119 // Start with a snapshot of the cache 1120 Map<String, Cursor> accountCache = mCacheAccount.getSnapshot(); 1121 long accountId = Account.NO_ACCOUNT; 1122 // Find the account with "isDefault" set, or the lowest account ID otherwise. 1123 // Note that the snapshot from the cached isn't guaranteed to be sorted in any 1124 // way. 1125 Collection<Cursor> accounts = accountCache.values(); 1126 for (Cursor accountCursor: accounts) { 1127 // For now, at least, we can have zero count cursors (e.g. if someone looks 1128 // up a non-existent id); we need to skip these 1129 if (accountCursor.moveToFirst()) { 1130 boolean isDefault = 1131 accountCursor.getInt(Account.CONTENT_IS_DEFAULT_COLUMN) == 1; 1132 long iterId = accountCursor.getLong(Account.CONTENT_ID_COLUMN); 1133 // We'll remember this one if it's the default or the first one we see 1134 if (isDefault) { 1135 accountId = iterId; 1136 break; 1137 } else if ((accountId == Account.NO_ACCOUNT) || (iterId < accountId)) { 1138 accountId = iterId; 1139 } 1140 } 1141 } 1142 // Return a cursor with an id projection 1143 MatrixCursor mc = new MatrixCursor(EmailContent.ID_PROJECTION); 1144 mc.addRow(new Object[] {accountId}); 1145 c = mc; 1146 break; 1147 case MAILBOX_ID_FROM_ACCOUNT_AND_TYPE: 1148 // Get accountId and type and find the mailbox in our map 1149 List<String> pathSegments = uri.getPathSegments(); 1150 accountId = Long.parseLong(pathSegments.get(1)); 1151 int type = Integer.parseInt(pathSegments.get(2)); 1152 long mailboxId = getMailboxIdFromMailboxTypeMap(accountId, type); 1153 // Return a cursor with an id projection 1154 mc = new MatrixCursor(EmailContent.ID_PROJECTION); 1155 mc.addRow(new Object[] {mailboxId}); 1156 c = mc; 1157 break; 1158 case BODY: 1159 case MESSAGE: 1160 case UPDATED_MESSAGE: 1161 case DELETED_MESSAGE: 1162 case ATTACHMENT: 1163 case MAILBOX: 1164 case ACCOUNT: 1165 case HOSTAUTH: 1166 case POLICY: 1167 case QUICK_RESPONSE: 1168 // Special-case "count of accounts"; it's common and we always know it 1169 if (match == ACCOUNT && Arrays.equals(projection, EmailContent.COUNT_COLUMNS) && 1170 selection == null && limit.equals("1")) { 1171 int accountCount = mMailboxTypeMap.size(); 1172 // In the rare case there are MAX_CACHED_ACCOUNTS or more, we can't do this 1173 if (accountCount < MAX_CACHED_ACCOUNTS) { 1174 mc = new MatrixCursor(projection, 1); 1175 mc.addRow(new Object[] {accountCount}); 1176 c = mc; 1177 break; 1178 } 1179 } 1180 c = db.query(tableName, projection, 1181 selection, selectionArgs, null, null, sortOrder, limit); 1182 break; 1183 case BODY_ID: 1184 case MESSAGE_ID: 1185 case DELETED_MESSAGE_ID: 1186 case UPDATED_MESSAGE_ID: 1187 case ATTACHMENT_ID: 1188 case MAILBOX_ID: 1189 case ACCOUNT_ID: 1190 case HOSTAUTH_ID: 1191 case POLICY_ID: 1192 case QUICK_RESPONSE_ID: 1193 id = uri.getPathSegments().get(1); 1194 if (cache != null) { 1195 c = cache.getCachedCursor(id, projection); 1196 } 1197 if (c == null) { 1198 CacheToken token = null; 1199 if (cache != null) { 1200 token = cache.getCacheToken(id); 1201 } 1202 c = db.query(tableName, projection, whereWithId(id, selection), 1203 selectionArgs, null, null, sortOrder, limit); 1204 if (cache != null) { 1205 c = cache.putCursor(c, id, projection, token); 1206 } 1207 } 1208 break; 1209 case ATTACHMENTS_MESSAGE_ID: 1210 // All attachments for the given message 1211 id = uri.getPathSegments().get(2); 1212 c = db.query(Attachment.TABLE_NAME, projection, 1213 whereWith(Attachment.MESSAGE_KEY + "=" + id, selection), 1214 selectionArgs, null, null, sortOrder, limit); 1215 break; 1216 case QUICK_RESPONSE_ACCOUNT_ID: 1217 // All quick responses for the given account 1218 id = uri.getPathSegments().get(2); 1219 c = db.query(QuickResponse.TABLE_NAME, projection, 1220 whereWith(QuickResponse.ACCOUNT_KEY + "=" + id, selection), 1221 selectionArgs, null, null, sortOrder); 1222 break; 1223 default: 1224 throw new IllegalArgumentException("Unknown URI " + uri); 1225 } 1226 } catch (SQLiteException e) { 1227 checkDatabases(); 1228 throw e; 1229 } catch (RuntimeException e) { 1230 checkDatabases(); 1231 e.printStackTrace(); 1232 throw e; 1233 } finally { 1234 if (cache != null && c != null && Email.DEBUG) { 1235 cache.recordQueryTime(c, System.nanoTime() - time); 1236 } 1237 if (c == null) { 1238 // This should never happen, but let's be sure to log it... 1239 Log.e(TAG, "Query returning null for uri: " + uri + ", selection: " + selection); 1240 } 1241 } 1242 1243 if ((c != null) && !isTemporary()) { 1244 c.setNotificationUri(getContext().getContentResolver(), uri); 1245 } 1246 return c; 1247 } 1248 1249 private String whereWithId(String id, String selection) { 1250 StringBuilder sb = new StringBuilder(256); 1251 sb.append("_id="); 1252 sb.append(id); 1253 if (selection != null) { 1254 sb.append(" AND ("); 1255 sb.append(selection); 1256 sb.append(')'); 1257 } 1258 return sb.toString(); 1259 } 1260 1261 /** 1262 * Combine a locally-generated selection with a user-provided selection 1263 * 1264 * This introduces risk that the local selection might insert incorrect chars 1265 * into the SQL, so use caution. 1266 * 1267 * @param where locally-generated selection, must not be null 1268 * @param selection user-provided selection, may be null 1269 * @return a single selection string 1270 */ 1271 private String whereWith(String where, String selection) { 1272 if (selection == null) { 1273 return where; 1274 } 1275 StringBuilder sb = new StringBuilder(where); 1276 sb.append(" AND ("); 1277 sb.append(selection); 1278 sb.append(')'); 1279 1280 return sb.toString(); 1281 } 1282 1283 /** 1284 * Restore a HostAuth from a database, given its unique id 1285 * @param db the database 1286 * @param id the unique id (_id) of the row 1287 * @return a fully populated HostAuth or null if the row does not exist 1288 */ 1289 private static HostAuth restoreHostAuth(SQLiteDatabase db, long id) { 1290 Cursor c = db.query(HostAuth.TABLE_NAME, HostAuth.CONTENT_PROJECTION, 1291 HostAuth.RECORD_ID + "=?", new String[] {Long.toString(id)}, null, null, null); 1292 try { 1293 if (c.moveToFirst()) { 1294 HostAuth hostAuth = new HostAuth(); 1295 hostAuth.restore(c); 1296 return hostAuth; 1297 } 1298 return null; 1299 } finally { 1300 c.close(); 1301 } 1302 } 1303 1304 /** 1305 * Copy the Account and HostAuth tables from one database to another 1306 * @param fromDatabase the source database 1307 * @param toDatabase the destination database 1308 * @return the number of accounts copied, or -1 if an error occurred 1309 */ 1310 private static int copyAccountTables(SQLiteDatabase fromDatabase, SQLiteDatabase toDatabase) { 1311 if (fromDatabase == null || toDatabase == null) return -1; 1312 1313 // Lock both databases; for the "from" database, we don't want anyone changing it from 1314 // under us; for the "to" database, we want to make the operation atomic 1315 int copyCount = 0; 1316 fromDatabase.beginTransaction(); 1317 try { 1318 toDatabase.beginTransaction(); 1319 try { 1320 // Delete anything hanging around here 1321 toDatabase.delete(Account.TABLE_NAME, null, null); 1322 toDatabase.delete(HostAuth.TABLE_NAME, null, null); 1323 1324 // Get our account cursor 1325 Cursor c = fromDatabase.query(Account.TABLE_NAME, Account.CONTENT_PROJECTION, 1326 null, null, null, null, null); 1327 if (c == null) return 0; 1328 Log.d(TAG, "fromDatabase accounts: " + c.getCount()); 1329 try { 1330 // Loop through accounts, copying them and associated host auth's 1331 while (c.moveToNext()) { 1332 Account account = new Account(); 1333 account.restore(c); 1334 1335 // Clear security sync key and sync key, as these were specific to the 1336 // state of the account, and we've reset that... 1337 // Clear policy key so that we can re-establish policies from the server 1338 // TODO This is pretty EAS specific, but there's a lot of that around 1339 account.mSecuritySyncKey = null; 1340 account.mSyncKey = null; 1341 account.mPolicyKey = 0; 1342 1343 // Copy host auth's and update foreign keys 1344 HostAuth hostAuth = restoreHostAuth(fromDatabase, 1345 account.mHostAuthKeyRecv); 1346 1347 // The account might have gone away, though very unlikely 1348 if (hostAuth == null) continue; 1349 account.mHostAuthKeyRecv = toDatabase.insert(HostAuth.TABLE_NAME, null, 1350 hostAuth.toContentValues()); 1351 1352 // EAS accounts have no send HostAuth 1353 if (account.mHostAuthKeySend > 0) { 1354 hostAuth = restoreHostAuth(fromDatabase, account.mHostAuthKeySend); 1355 // Belt and suspenders; I can't imagine that this is possible, 1356 // since we checked the validity of the account above, and the 1357 // database is now locked 1358 if (hostAuth == null) continue; 1359 account.mHostAuthKeySend = toDatabase.insert( 1360 HostAuth.TABLE_NAME, null, hostAuth.toContentValues()); 1361 } 1362 1363 // Now, create the account in the "to" database 1364 toDatabase.insert(Account.TABLE_NAME, null, account.toContentValues()); 1365 copyCount++; 1366 } 1367 } finally { 1368 c.close(); 1369 } 1370 1371 // Say it's ok to commit 1372 toDatabase.setTransactionSuccessful(); 1373 } finally { 1374 // STOPSHIP: Remove logging here and in at endTransaction() below 1375 Log.d(TAG, "ending toDatabase transaction; copyCount = " + copyCount); 1376 toDatabase.endTransaction(); 1377 } 1378 } catch (SQLiteException ex) { 1379 Log.w(TAG, "Exception while copying account tables", ex); 1380 copyCount = -1; 1381 } finally { 1382 Log.d(TAG, "ending fromDatabase transaction; copyCount = " + copyCount); 1383 fromDatabase.endTransaction(); 1384 } 1385 return copyCount; 1386 } 1387 1388 private static SQLiteDatabase getBackupDatabase(Context context) { 1389 DBHelper.DatabaseHelper helper = new DBHelper.DatabaseHelper(context, BACKUP_DATABASE_NAME); 1390 return helper.getWritableDatabase(); 1391 } 1392 1393 /** 1394 * Backup account data, returning the number of accounts backed up 1395 */ 1396 private static int backupAccounts(Context context, SQLiteDatabase mainDatabase) { 1397 if (Email.DEBUG) { 1398 Log.d(TAG, "backupAccounts..."); 1399 } 1400 SQLiteDatabase backupDatabase = getBackupDatabase(context); 1401 try { 1402 int numBackedUp = copyAccountTables(mainDatabase, backupDatabase); 1403 if (numBackedUp < 0) { 1404 Log.e(TAG, "Account backup failed!"); 1405 } else if (Email.DEBUG) { 1406 Log.d(TAG, "Backed up " + numBackedUp + " accounts..."); 1407 } 1408 return numBackedUp; 1409 } finally { 1410 if (backupDatabase != null) { 1411 backupDatabase.close(); 1412 } 1413 } 1414 } 1415 1416 /** 1417 * Restore account data, returning the number of accounts restored 1418 */ 1419 private static int restoreAccounts(Context context, SQLiteDatabase mainDatabase) { 1420 if (Email.DEBUG) { 1421 Log.d(TAG, "restoreAccounts..."); 1422 } 1423 SQLiteDatabase backupDatabase = getBackupDatabase(context); 1424 try { 1425 int numRecovered = copyAccountTables(backupDatabase, mainDatabase); 1426 if (numRecovered > 0) { 1427 Log.e(TAG, "Recovered " + numRecovered + " accounts!"); 1428 } else if (numRecovered < 0) { 1429 Log.e(TAG, "Account recovery failed?"); 1430 } else if (Email.DEBUG) { 1431 Log.d(TAG, "No accounts to restore..."); 1432 } 1433 return numRecovered; 1434 } finally { 1435 if (backupDatabase != null) { 1436 backupDatabase.close(); 1437 } 1438 } 1439 } 1440 1441 @Override 1442 public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { 1443 // Handle this special case the fastest possible way 1444 if (uri == INTEGRITY_CHECK_URI) { 1445 checkDatabases(); 1446 return 0; 1447 } else if (uri == ACCOUNT_BACKUP_URI) { 1448 return backupAccounts(getContext(), getDatabase(getContext())); 1449 } 1450 1451 // Notify all existing cursors, except for ACCOUNT_RESET_NEW_COUNT(_ID) 1452 Uri notificationUri = EmailContent.CONTENT_URI; 1453 1454 int match = findMatch(uri, "update"); 1455 Context context = getContext(); 1456 ContentResolver resolver = context.getContentResolver(); 1457 // See the comment at delete(), above 1458 SQLiteDatabase db = getDatabase(context); 1459 int table = match >> BASE_SHIFT; 1460 int result; 1461 1462 // We do NOT allow setting of unreadCount/messageCount via the provider 1463 // These columns are maintained via triggers 1464 if (match == MAILBOX_ID || match == MAILBOX) { 1465 values.remove(MailboxColumns.UNREAD_COUNT); 1466 values.remove(MailboxColumns.MESSAGE_COUNT); 1467 } 1468 1469 ContentCache cache = mContentCaches[table]; 1470 String tableName = TABLE_NAMES[table]; 1471 String id = "0"; 1472 1473 try { 1474 outer: 1475 switch (match) { 1476 case MAILBOX_ID_ADD_TO_FIELD: 1477 case ACCOUNT_ID_ADD_TO_FIELD: 1478 id = uri.getPathSegments().get(1); 1479 String field = values.getAsString(EmailContent.FIELD_COLUMN_NAME); 1480 Long add = values.getAsLong(EmailContent.ADD_COLUMN_NAME); 1481 if (field == null || add == null) { 1482 throw new IllegalArgumentException("No field/add specified " + uri); 1483 } 1484 ContentValues actualValues = new ContentValues(); 1485 if (cache != null) { 1486 cache.lock(id); 1487 } 1488 try { 1489 db.beginTransaction(); 1490 try { 1491 Cursor c = db.query(tableName, 1492 new String[] {EmailContent.RECORD_ID, field}, 1493 whereWithId(id, selection), 1494 selectionArgs, null, null, null); 1495 try { 1496 result = 0; 1497 String[] bind = new String[1]; 1498 if (c.moveToNext()) { 1499 bind[0] = c.getString(0); // _id 1500 long value = c.getLong(1) + add; 1501 actualValues.put(field, value); 1502 result = db.update(tableName, actualValues, ID_EQUALS, bind); 1503 } 1504 db.setTransactionSuccessful(); 1505 } finally { 1506 c.close(); 1507 } 1508 } finally { 1509 db.endTransaction(); 1510 } 1511 } finally { 1512 if (cache != null) { 1513 cache.unlock(id, actualValues); 1514 } 1515 } 1516 break; 1517 case SYNCED_MESSAGE_ID: 1518 case UPDATED_MESSAGE_ID: 1519 case MESSAGE_ID: 1520 case BODY_ID: 1521 case ATTACHMENT_ID: 1522 case MAILBOX_ID: 1523 case ACCOUNT_ID: 1524 case HOSTAUTH_ID: 1525 case QUICK_RESPONSE_ID: 1526 case POLICY_ID: 1527 id = uri.getPathSegments().get(1); 1528 if (cache != null) { 1529 cache.lock(id); 1530 } 1531 try { 1532 if (match == SYNCED_MESSAGE_ID) { 1533 // For synced messages, first copy the old message to the updated table 1534 // Note the insert or ignore semantics, guaranteeing that only the first 1535 // update will be reflected in the updated message table; therefore this 1536 // row will always have the "original" data 1537 db.execSQL(UPDATED_MESSAGE_INSERT + id); 1538 } else if (match == MESSAGE_ID) { 1539 db.execSQL(UPDATED_MESSAGE_DELETE + id); 1540 } 1541 result = db.update(tableName, values, whereWithId(id, selection), 1542 selectionArgs); 1543 } catch (SQLiteException e) { 1544 // Null out values (so they aren't cached) and re-throw 1545 values = null; 1546 throw e; 1547 } finally { 1548 if (cache != null) { 1549 cache.unlock(id, values); 1550 } 1551 } 1552 if (match == ATTACHMENT_ID) { 1553 long attId = Integer.parseInt(id); 1554 if (values.containsKey(Attachment.FLAGS)) { 1555 int flags = values.getAsInteger(Attachment.FLAGS); 1556 mAttachmentService.attachmentChanged(context, attId, flags); 1557 } 1558 } 1559 break; 1560 case BODY: 1561 case MESSAGE: 1562 case UPDATED_MESSAGE: 1563 case ATTACHMENT: 1564 case MAILBOX: 1565 case ACCOUNT: 1566 case HOSTAUTH: 1567 case POLICY: 1568 switch(match) { 1569 // To avoid invalidating the cache on updates, we execute them one at a 1570 // time using the XXX_ID uri; these are all executed atomically 1571 case ACCOUNT: 1572 case MAILBOX: 1573 case HOSTAUTH: 1574 case POLICY: 1575 Cursor c = db.query(tableName, EmailContent.ID_PROJECTION, 1576 selection, selectionArgs, null, null, null); 1577 db.beginTransaction(); 1578 result = 0; 1579 try { 1580 while (c.moveToNext()) { 1581 update(ContentUris.withAppendedId( 1582 uri, c.getLong(EmailContent.ID_PROJECTION_COLUMN)), 1583 values, null, null); 1584 result++; 1585 } 1586 db.setTransactionSuccessful(); 1587 } finally { 1588 db.endTransaction(); 1589 c.close(); 1590 } 1591 break outer; 1592 // Any cached table other than those above should be invalidated here 1593 case MESSAGE: 1594 // If we're doing some generic update, the whole cache needs to be 1595 // invalidated. This case should be quite rare 1596 cache.invalidate("Update", uri, selection); 1597 //$FALL-THROUGH$ 1598 default: 1599 result = db.update(tableName, values, selection, selectionArgs); 1600 break outer; 1601 } 1602 case ACCOUNT_RESET_NEW_COUNT_ID: 1603 id = uri.getPathSegments().get(1); 1604 if (cache != null) { 1605 cache.lock(id); 1606 } 1607 ContentValues newMessageCount = CONTENT_VALUES_RESET_NEW_MESSAGE_COUNT; 1608 if (values != null) { 1609 Long set = values.getAsLong(EmailContent.SET_COLUMN_NAME); 1610 if (set != null) { 1611 newMessageCount = new ContentValues(); 1612 newMessageCount.put(Account.NEW_MESSAGE_COUNT, set); 1613 } 1614 } 1615 try { 1616 result = db.update(tableName, newMessageCount, 1617 whereWithId(id, selection), selectionArgs); 1618 } finally { 1619 if (cache != null) { 1620 cache.unlock(id, values); 1621 } 1622 } 1623 notificationUri = Account.CONTENT_URI; // Only notify account cursors. 1624 break; 1625 case ACCOUNT_RESET_NEW_COUNT: 1626 result = db.update(tableName, CONTENT_VALUES_RESET_NEW_MESSAGE_COUNT, 1627 selection, selectionArgs); 1628 // Affects all accounts. Just invalidate all account cache. 1629 cache.invalidate("Reset all new counts", null, null); 1630 notificationUri = Account.CONTENT_URI; // Only notify account cursors. 1631 break; 1632 default: 1633 throw new IllegalArgumentException("Unknown URI " + uri); 1634 } 1635 } catch (SQLiteException e) { 1636 checkDatabases(); 1637 throw e; 1638 } 1639 1640 // Notify all notifier cursors 1641 sendNotifierChange(getBaseNotificationUri(match), NOTIFICATION_OP_UPDATE, id); 1642 1643 resolver.notifyChange(notificationUri, null); 1644 return result; 1645 } 1646 1647 /** 1648 * Returns the base notification URI for the given content type. 1649 * 1650 * @param match The type of content that was modified. 1651 */ 1652 private Uri getBaseNotificationUri(int match) { 1653 Uri baseUri = null; 1654 switch (match) { 1655 case MESSAGE: 1656 case MESSAGE_ID: 1657 case SYNCED_MESSAGE_ID: 1658 baseUri = Message.NOTIFIER_URI; 1659 break; 1660 case ACCOUNT: 1661 case ACCOUNT_ID: 1662 baseUri = Account.NOTIFIER_URI; 1663 break; 1664 } 1665 return baseUri; 1666 } 1667 1668 /** 1669 * Sends a change notification to any cursors observers of the given base URI. The final 1670 * notification URI is dynamically built to contain the specified information. It will be 1671 * of the format <<baseURI>>/<<op>>/<<id>>; where <<op>> and <<id>> are optional depending 1672 * upon the given values. For message-related notifications, we also notify the widget 1673 * provider. 1674 * NOTE: If <<op>> is specified, notifications for <<baseURI>>/<<id>> will NOT be invoked. 1675 * If this is necessary, it can be added. However, due to the implementation of 1676 * {@link ContentObserver}, observers of <<baseURI>> will receive multiple notifications. 1677 * 1678 * @param baseUri The base URI to send notifications to. Must be able to take appended IDs. 1679 * @param op Optional operation to be appended to the URI. 1680 * @param id If a positive value, the ID to append to the base URI. Otherwise, no ID will be 1681 * appended to the base URI. 1682 */ 1683 private void sendNotifierChange(Uri baseUri, String op, String id) { 1684 if (baseUri == null) return; 1685 Uri uri = baseUri; 1686 1687 // Append the operation, if specified 1688 if (op != null) { 1689 uri = baseUri.buildUpon().appendEncodedPath(op).build(); 1690 } 1691 1692 long longId = 0L; 1693 try { 1694 longId = Long.valueOf(id); 1695 } catch (NumberFormatException ignore) {} 1696 1697 final ContentResolver resolver = getContext().getContentResolver(); 1698 if (longId > 0) { 1699 resolver.notifyChange(ContentUris.withAppendedId(uri, longId), null); 1700 } else { 1701 resolver.notifyChange(uri, null); 1702 } 1703 1704 // If a message has changed, notify any widgets 1705 if (baseUri.equals(Message.NOTIFIER_URI)) { 1706 sendMessageListDataChangedNotification(); 1707 } 1708 } 1709 1710 private void sendMessageListDataChangedNotification() { 1711 final Context context = getContext(); 1712 final Intent intent = new Intent(ACTION_NOTIFY_MESSAGE_LIST_DATASET_CHANGED); 1713 // Ideally this intent would contain information about which account changed, to limit the 1714 // updates to that particular account. Unfortunately, that information is not available in 1715 // sendNotifierChange(). 1716 context.sendBroadcast(intent); 1717 } 1718 1719 @Override 1720 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) 1721 throws OperationApplicationException { 1722 Context context = getContext(); 1723 SQLiteDatabase db = getDatabase(context); 1724 db.beginTransaction(); 1725 try { 1726 ContentProviderResult[] results = super.applyBatch(operations); 1727 db.setTransactionSuccessful(); 1728 return results; 1729 } finally { 1730 db.endTransaction(); 1731 } 1732 } 1733 1734 /** 1735 * For testing purposes, check whether a given row is cached 1736 * @param baseUri the base uri of the EmailContent 1737 * @param id the row id of the EmailContent 1738 * @return whether or not the row is currently cached 1739 */ 1740 @VisibleForTesting 1741 protected boolean isCached(Uri baseUri, long id) { 1742 int match = findMatch(baseUri, "isCached"); 1743 int table = match >> BASE_SHIFT; 1744 ContentCache cache = mContentCaches[table]; 1745 if (cache == null) return false; 1746 Cursor cc = cache.get(Long.toString(id)); 1747 return (cc != null); 1748 } 1749 1750 public static interface AttachmentService { 1751 /** 1752 * Notify the service that an attachment has changed. 1753 */ 1754 void attachmentChanged(Context context, long id, int flags); 1755 } 1756 1757 private final AttachmentService DEFAULT_ATTACHMENT_SERVICE = new AttachmentService() { 1758 @Override 1759 public void attachmentChanged(Context context, long id, int flags) { 1760 // The default implementation delegates to the real service. 1761 AttachmentDownloadService.attachmentChanged(context, id, flags); 1762 } 1763 }; 1764 private AttachmentService mAttachmentService = DEFAULT_ATTACHMENT_SERVICE; 1765 1766 /** 1767 * Injects a custom attachment service handler. If null is specified, will reset to the 1768 * default service. 1769 */ 1770 public void injectAttachmentService(AttachmentService as) { 1771 mAttachmentService = (as == null) ? DEFAULT_ATTACHMENT_SERVICE : as; 1772 } 1773 1774 // SELECT DISTINCT Boxes._id, Boxes.unreadCount count(Message._id) from Message, 1775 // (SELECT _id, unreadCount, messageCount, lastNotifiedMessageCount, lastNotifiedMessageKey 1776 // FROM Mailbox WHERE accountKey=6 AND ((type = 0) OR (syncInterval!=0 AND syncInterval!=-1))) 1777 // AS Boxes 1778 // WHERE Boxes.messageCount!=Boxes.lastNotifiedMessageCount 1779 // OR (Boxes._id=Message.mailboxKey AND Message._id>Boxes.lastNotifiedMessageKey) 1780 // AND flagRead = 0 AND timeStamp != 0 1781 // TODO: This query can be simplified a bit 1782 private static final String NOTIFICATION_QUERY = 1783 "SELECT DISTINCT Boxes." + MailboxColumns.ID + ", Boxes." + MailboxColumns.UNREAD_COUNT + 1784 ", count(" + Message.TABLE_NAME + "." + MessageColumns.ID + ")" + 1785 " FROM " + 1786 Message.TABLE_NAME + "," + 1787 "(SELECT " + MailboxColumns.ID + "," + MailboxColumns.UNREAD_COUNT + "," + 1788 MailboxColumns.MESSAGE_COUNT + "," + MailboxColumns.LAST_NOTIFIED_MESSAGE_COUNT + 1789 "," + MailboxColumns.LAST_NOTIFIED_MESSAGE_KEY + " FROM " + Mailbox.TABLE_NAME + 1790 " WHERE " + MailboxColumns.ACCOUNT_KEY + "=?" + 1791 " AND (" + MailboxColumns.TYPE + "=" + Mailbox.TYPE_INBOX + " OR (" 1792 + MailboxColumns.SYNC_INTERVAL + "!=0 AND " + 1793 MailboxColumns.SYNC_INTERVAL + "!=-1))) AS Boxes " + 1794 "WHERE Boxes." + MailboxColumns.ID + '=' + Message.TABLE_NAME + "." + 1795 MessageColumns.MAILBOX_KEY + " AND " + Message.TABLE_NAME + "." + 1796 MessageColumns.ID + ">Boxes." + MailboxColumns.LAST_NOTIFIED_MESSAGE_KEY + 1797 " AND " + MessageColumns.FLAG_READ + "=0 AND " + MessageColumns.TIMESTAMP + "!=0"; 1798 1799 public Cursor notificationQuery(Uri uri) { 1800 SQLiteDatabase db = getDatabase(getContext()); 1801 String accountId = uri.getLastPathSegment(); 1802 return db.rawQuery(NOTIFICATION_QUERY, new String[] {accountId}); 1803 } 1804 1805 public Cursor mostRecentMessageQuery(Uri uri) { 1806 SQLiteDatabase db = getDatabase(getContext()); 1807 String mailboxId = uri.getLastPathSegment(); 1808 return db.rawQuery("select max(_id) from Message where mailboxKey=?", 1809 new String[] {mailboxId}); 1810 } 1811 } 1812
