partsToUpdate) {
+ Assert.isNotMainThread();
+ Assert.isTrue(dbWrapper.getDatabase().inTransaction());
+ final ContentValues values = new ContentValues();
+ for (final MessagePartData messagePart : partsToUpdate) {
+ values.clear();
+ messagePart.populate(values);
+ updatePartRowIfExists(dbWrapper, messagePart.getPartId(), values);
+ }
+ values.clear();
+ message.populate(values);
+ updateMessageRowIfExists(dbWrapper, message.getMessageId(), values);
+ }
+
+ /**
+ * Delete all parts for a message
+ */
+ static void deletePartsForMessage(final DatabaseWrapper dbWrapper,
+ final String messageId) {
+ final int cnt = dbWrapper.delete(DatabaseHelper.PARTS_TABLE,
+ PartColumns.MESSAGE_ID + " =?",
+ new String[] { messageId });
+ Assert.inRange(cnt, 0, Integer.MAX_VALUE);
+ }
+
+ /**
+ * Delete one message and update the conversation (if necessary).
+ *
+ * @return number of rows deleted (should be 1 or 0).
+ */
+ @DoesNotRunOnMainThread
+ public static int deleteMessage(final DatabaseWrapper dbWrapper, final String messageId) {
+ Assert.isNotMainThread();
+ dbWrapper.beginTransaction();
+ try {
+ // Read message to find out which conversation it is in
+ final MessageData message = BugleDatabaseOperations.readMessage(dbWrapper, messageId);
+
+ int count = 0;
+ if (message != null) {
+ final String conversationId = message.getConversationId();
+ // Delete message
+ count = dbWrapper.delete(DatabaseHelper.MESSAGES_TABLE,
+ MessageColumns._ID + "=?", new String[] { messageId });
+
+ if (!deleteConversationIfEmptyInTransaction(dbWrapper, conversationId)) {
+ // TODO: Should we leave the conversation sort timestamp alone?
+ refreshConversationMetadataInTransaction(dbWrapper, conversationId,
+ false/* shouldAutoSwitchSelfId */, false/*archived*/);
+ }
+ }
+ dbWrapper.setTransactionSuccessful();
+ return count;
+ } finally {
+ dbWrapper.endTransaction();
+ }
+ }
+
+ /**
+ * Deletes the conversation if there are zero non-draft messages left.
+ *
+ * This is necessary because the telephony database has a trigger that deletes threads after
+ * their last message is deleted. We need to ensure that if a thread goes away, we also delete
+ * the conversation in Bugle. We don't store draft messages in telephony, so we ignore those
+ * when querying for the # of messages in the conversation.
+ *
+ * @return true if the conversation was deleted
+ */
+ @DoesNotRunOnMainThread
+ public static boolean deleteConversationIfEmptyInTransaction(final DatabaseWrapper dbWrapper,
+ final String conversationId) {
+ Assert.isNotMainThread();
+ Assert.isTrue(dbWrapper.getDatabase().inTransaction());
+ Cursor cursor = null;
+ try {
+ // TODO: The refreshConversationMetadataInTransaction method below uses this
+ // same query; maybe they should share this logic?
+
+ // Check to see if there are any (non-draft) messages in the conversation
+ cursor = dbWrapper.query(DatabaseHelper.MESSAGES_TABLE,
+ REFRESH_CONVERSATION_MESSAGE_PROJECTION,
+ MessageColumns.CONVERSATION_ID + "=? AND " +
+ MessageColumns.STATUS + "!=" + MessageData.BUGLE_STATUS_OUTGOING_DRAFT,
+ new String[] { conversationId }, null, null,
+ MessageColumns.RECEIVED_TIMESTAMP + " DESC", "1" /* limit */);
+ if (cursor.getCount() == 0) {
+ dbWrapper.delete(DatabaseHelper.CONVERSATIONS_TABLE,
+ ConversationColumns._ID + "=?", new String[] { conversationId });
+ LogUtil.i(TAG,
+ "BugleDatabaseOperations: Deleted empty conversation " + conversationId);
+ return true;
+ } else {
+ return false;
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ }
+
+ private static final String[] REFRESH_CONVERSATION_MESSAGE_PROJECTION = new String[] {
+ MessageColumns._ID,
+ MessageColumns.RECEIVED_TIMESTAMP,
+ MessageColumns.SENDER_PARTICIPANT_ID
+ };
+
+ /**
+ * Update conversation snippet, timestamp and optionally self id to match latest message in
+ * conversation.
+ */
+ @DoesNotRunOnMainThread
+ public static void refreshConversationMetadataInTransaction(final DatabaseWrapper dbWrapper,
+ final String conversationId, final boolean shouldAutoSwitchSelfId,
+ boolean keepArchived) {
+ Assert.isNotMainThread();
+ Assert.isTrue(dbWrapper.getDatabase().inTransaction());
+ Cursor cursor = null;
+ try {
+ // Check to see if there are any (non-draft) messages in the conversation
+ cursor = dbWrapper.query(DatabaseHelper.MESSAGES_TABLE,
+ REFRESH_CONVERSATION_MESSAGE_PROJECTION,
+ MessageColumns.CONVERSATION_ID + "=? AND " +
+ MessageColumns.STATUS + "!=" + MessageData.BUGLE_STATUS_OUTGOING_DRAFT,
+ new String[] { conversationId }, null, null,
+ MessageColumns.RECEIVED_TIMESTAMP + " DESC", "1" /* limit */);
+
+ if (cursor.moveToFirst()) {
+ // Refresh latest message in conversation
+ final String latestMessageId = cursor.getString(0);
+ final long latestMessageTimestamp = cursor.getLong(1);
+ final String senderParticipantId = cursor.getString(2);
+ final boolean senderBlocked = isBlockedParticipant(dbWrapper, senderParticipantId);
+ updateConversationMetadataInTransaction(dbWrapper, conversationId,
+ latestMessageId, latestMessageTimestamp, senderBlocked || keepArchived,
+ shouldAutoSwitchSelfId);
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ }
+
+ /**
+ * When moving/removing an existing message update conversation metadata if necessary
+ * @param dbWrapper db wrapper
+ * @param conversationId conversation to modify
+ * @param messageId message that is leaving the conversation
+ * @param shouldAutoSwitchSelfId should we try to auto-switch the conversation's self-id as a
+ * result of this call when we see a new latest message?
+ * @param keepArchived should we keep the conversation archived despite refresh
+ */
+ @DoesNotRunOnMainThread
+ public static void maybeRefreshConversationMetadataInTransaction(
+ final DatabaseWrapper dbWrapper, final String conversationId, final String messageId,
+ final boolean shouldAutoSwitchSelfId, final boolean keepArchived) {
+ Assert.isNotMainThread();
+ boolean refresh = true;
+ if (!TextUtils.isEmpty(messageId)) {
+ refresh = false;
+ // Look for an existing conversation in the db with this conversation id
+ Cursor cursor = null;
+ try {
+ cursor = dbWrapper.query(DatabaseHelper.CONVERSATIONS_TABLE,
+ new String[] { ConversationColumns.LATEST_MESSAGE_ID },
+ ConversationColumns._ID + "=?",
+ new String[] { conversationId },
+ null, null, null);
+ Assert.inRange(cursor.getCount(), 0, 1);
+ if (cursor.moveToFirst()) {
+ refresh = TextUtils.equals(cursor.getString(0), messageId);
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ }
+ if (refresh) {
+ // TODO: I think it is okay to delete the conversation if it is empty...
+ refreshConversationMetadataInTransaction(dbWrapper, conversationId,
+ shouldAutoSwitchSelfId, keepArchived);
+ }
+ }
+
+
+
+ // SQL statement to query latest message if for particular conversation
+ private static final String QUERY_CONVERSATIONS_LATEST_MESSAGE_SQL = "SELECT "
+ + ConversationColumns.LATEST_MESSAGE_ID + " FROM " + DatabaseHelper.CONVERSATIONS_TABLE
+ + " WHERE " + ConversationColumns._ID + "=? LIMIT 1";
+
+ /**
+ * Note this is not thread safe so callers need to make sure they own the wrapper + statements
+ * while they call this and use the returned value.
+ */
+ @DoesNotRunOnMainThread
+ public static SQLiteStatement getQueryConversationsLatestMessageStatement(
+ final DatabaseWrapper db, final String conversationId) {
+ Assert.isNotMainThread();
+ final SQLiteStatement query = db.getStatementInTransaction(
+ DatabaseWrapper.INDEX_QUERY_CONVERSATIONS_LATEST_MESSAGE,
+ QUERY_CONVERSATIONS_LATEST_MESSAGE_SQL);
+ query.clearBindings();
+ query.bindString(1, conversationId);
+ return query;
+ }
+
+ // SQL statement to query latest message if for particular conversation
+ private static final String QUERY_MESSAGES_LATEST_MESSAGE_SQL = "SELECT "
+ + MessageColumns._ID + " FROM " + DatabaseHelper.MESSAGES_TABLE
+ + " WHERE " + MessageColumns.CONVERSATION_ID + "=? ORDER BY "
+ + MessageColumns.RECEIVED_TIMESTAMP + " DESC LIMIT 1";
+
+ /**
+ * Note this is not thread safe so callers need to make sure they own the wrapper + statements
+ * while they call this and use the returned value.
+ */
+ @DoesNotRunOnMainThread
+ public static SQLiteStatement getQueryMessagesLatestMessageStatement(
+ final DatabaseWrapper db, final String conversationId) {
+ Assert.isNotMainThread();
+ final SQLiteStatement query = db.getStatementInTransaction(
+ DatabaseWrapper.INDEX_QUERY_MESSAGES_LATEST_MESSAGE,
+ QUERY_MESSAGES_LATEST_MESSAGE_SQL);
+ query.clearBindings();
+ query.bindString(1, conversationId);
+ return query;
+ }
+
+ /**
+ * Update conversation metadata if necessary
+ * @param dbWrapper db wrapper
+ * @param conversationId conversation to modify
+ * @param shouldAutoSwitchSelfId should we try to auto-switch the conversation's self-id as a
+ * result of this call when we see a new latest message?
+ * @param keepArchived if the conversation should be kept archived
+ */
+ @DoesNotRunOnMainThread
+ public static void maybeRefreshConversationMetadataInTransaction(
+ final DatabaseWrapper dbWrapper, final String conversationId,
+ final boolean shouldAutoSwitchSelfId, boolean keepArchived) {
+ Assert.isNotMainThread();
+ String currentLatestMessageId = null;
+ String latestMessageId = null;
+ try {
+ final SQLiteStatement currentLatestMessageIdSql =
+ getQueryConversationsLatestMessageStatement(dbWrapper, conversationId);
+ currentLatestMessageId = currentLatestMessageIdSql.simpleQueryForString();
+
+ final SQLiteStatement latestMessageIdSql =
+ getQueryMessagesLatestMessageStatement(dbWrapper, conversationId);
+ latestMessageId = latestMessageIdSql.simpleQueryForString();
+ } catch (final SQLiteDoneException e) {
+ LogUtil.e(TAG, "BugleDatabaseOperations: Query for latest message failed", e);
+ }
+
+ if (TextUtils.isEmpty(currentLatestMessageId) ||
+ !TextUtils.equals(currentLatestMessageId, latestMessageId)) {
+ refreshConversationMetadataInTransaction(dbWrapper, conversationId,
+ shouldAutoSwitchSelfId, keepArchived);
+ }
+ }
+
+ static boolean getConversationExists(final DatabaseWrapper dbWrapper,
+ final String conversationId) {
+ // Look for an existing conversation in the db with this conversation id
+ Cursor cursor = null;
+ try {
+ cursor = dbWrapper.query(DatabaseHelper.CONVERSATIONS_TABLE,
+ new String[] { /* No projection */},
+ ConversationColumns._ID + "=?",
+ new String[] { conversationId },
+ null, null, null);
+ return cursor.getCount() == 1;
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ }
+
+ /** Preserve parts in message but clear the stored draft */
+ public static final int UPDATE_MODE_CLEAR_DRAFT = 1;
+ /** Add the message as a draft */
+ public static final int UPDATE_MODE_ADD_DRAFT = 2;
+
+ /**
+ * Update draft message for specified conversation
+ * @param dbWrapper local database (wrapped)
+ * @param conversationId conversation to update
+ * @param message Optional message to preserve attachments for (either as draft or for
+ * sending)
+ * @param updateMode either {@link #UPDATE_MODE_CLEAR_DRAFT} or
+ * {@link #UPDATE_MODE_ADD_DRAFT}
+ * @return message id of newly written draft (else null)
+ */
+ @DoesNotRunOnMainThread
+ public static String updateDraftMessageData(final DatabaseWrapper dbWrapper,
+ final String conversationId, @Nullable final MessageData message,
+ final int updateMode) {
+ Assert.isNotMainThread();
+ Assert.notNull(conversationId);
+ Assert.inRange(updateMode, UPDATE_MODE_CLEAR_DRAFT, UPDATE_MODE_ADD_DRAFT);
+ String messageId = null;
+ Cursor cursor = null;
+ dbWrapper.beginTransaction();
+ try {
+ // Find all draft parts for the current conversation
+ final SimpleArrayMap currentDraftParts = new SimpleArrayMap<>();
+ cursor = dbWrapper.query(DatabaseHelper.DRAFT_PARTS_VIEW,
+ MessagePartData.getProjection(),
+ MessageColumns.CONVERSATION_ID + " =?",
+ new String[] { conversationId }, null, null, null);
+ while (cursor.moveToNext()) {
+ final MessagePartData part = MessagePartData.createFromCursor(cursor);
+ if (part.isAttachment()) {
+ currentDraftParts.put(part.getContentUri(), part);
+ }
+ }
+ // Optionally, preserve attachments for "message"
+ final boolean conversationExists = getConversationExists(dbWrapper, conversationId);
+ if (message != null && conversationExists) {
+ for (final MessagePartData part : message.getParts()) {
+ if (part.isAttachment()) {
+ currentDraftParts.remove(part.getContentUri());
+ }
+ }
+ }
+
+ // Delete orphan content
+ for (int index = 0; index < currentDraftParts.size(); index++) {
+ final MessagePartData part = currentDraftParts.valueAt(index);
+ part.destroySync();
+ }
+
+ // Delete existing draft (cascade deletes parts)
+ dbWrapper.delete(DatabaseHelper.MESSAGES_TABLE,
+ MessageColumns.STATUS + "=? AND " + MessageColumns.CONVERSATION_ID + "=?",
+ new String[] {
+ Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_DRAFT),
+ conversationId
+ });
+
+ // Write new draft
+ if (updateMode == UPDATE_MODE_ADD_DRAFT && message != null
+ && message.hasContent() && conversationExists) {
+ Assert.equals(MessageData.BUGLE_STATUS_OUTGOING_DRAFT,
+ message.getStatus());
+
+ // Now add draft to message table
+ insertNewMessageInTransaction(dbWrapper, message);
+ messageId = message.getMessageId();
+ }
+
+ if (conversationExists) {
+ updateConversationDraftSnippetAndPreviewInTransaction(
+ dbWrapper, conversationId, message);
+
+ if (message != null && message.getSelfId() != null) {
+ updateConversationSelfIdInTransaction(dbWrapper, conversationId,
+ message.getSelfId());
+ }
+ }
+
+ dbWrapper.setTransactionSuccessful();
+ } finally {
+ dbWrapper.endTransaction();
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG,
+ "Updated draft message " + messageId + " for conversation " + conversationId);
+ }
+ return messageId;
+ }
+
+ /**
+ * Read the first draft message associated with this conversation.
+ * If none present create an empty (sms) draft message.
+ */
+ @DoesNotRunOnMainThread
+ public static MessageData readDraftMessageData(final DatabaseWrapper dbWrapper,
+ final String conversationId, final String conversationSelfId) {
+ Assert.isNotMainThread();
+ MessageData message = null;
+ Cursor cursor = null;
+ dbWrapper.beginTransaction();
+ try {
+ cursor = dbWrapper.query(DatabaseHelper.MESSAGES_TABLE,
+ MessageData.getProjection(),
+ MessageColumns.STATUS + "=? AND " + MessageColumns.CONVERSATION_ID + "=?",
+ new String[] {
+ Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_DRAFT),
+ conversationId
+ }, null, null, null);
+ Assert.inRange(cursor.getCount(), 0, 1);
+ if (cursor.moveToFirst()) {
+ message = new MessageData();
+ message.bindDraft(cursor, conversationSelfId);
+ readMessagePartsData(dbWrapper, message, true);
+ // Disconnect draft parts from DB
+ for (final MessagePartData part : message.getParts()) {
+ part.updatePartId(null);
+ part.updateMessageId(null);
+ }
+ message.updateMessageId(null);
+ }
+ dbWrapper.setTransactionSuccessful();
+ } finally {
+ dbWrapper.endTransaction();
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return message;
+ }
+
+ // Internal
+ private static void addParticipantToConversation(final DatabaseWrapper dbWrapper,
+ final ParticipantData participant, final String conversationId) {
+ final String participantId = getOrCreateParticipantInTransaction(dbWrapper, participant);
+ Assert.notNull(participantId);
+
+ // Add the participant to the conversation participants table
+ final ContentValues values = new ContentValues();
+ values.put(ConversationParticipantsColumns.CONVERSATION_ID, conversationId);
+ values.put(ConversationParticipantsColumns.PARTICIPANT_ID, participantId);
+ dbWrapper.insert(DatabaseHelper.CONVERSATION_PARTICIPANTS_TABLE, null, values);
+ }
+
+ /**
+ * Get string used as canonical recipient for participant cache for sub id
+ */
+ private static String getCanonicalRecipientFromSubId(final int subId) {
+ return "SELF(" + subId + ")";
+ }
+
+ /**
+ * Maps from a sub id or phone number to a participant id if there is one.
+ *
+ * @return If the participant is available in our cache, or the DB, this returns the
+ * participant id for the given subid/phone number. Otherwise it returns null.
+ */
+ @VisibleForTesting
+ private static String getParticipantId(final DatabaseWrapper dbWrapper,
+ final int subId, final String canonicalRecipient) {
+ // First check our memory cache for the participant Id
+ String participantId;
+ synchronized (sNormalizedPhoneNumberToParticipantIdCache) {
+ participantId = sNormalizedPhoneNumberToParticipantIdCache.get(canonicalRecipient);
+ }
+
+ if (participantId != null) {
+ return participantId;
+ }
+
+ // This code will only be executed for incremental additions.
+ Cursor cursor = null;
+ try {
+ if (subId != ParticipantData.OTHER_THAN_SELF_SUB_ID) {
+ // Now look for an existing participant in the db with this sub id.
+ cursor = dbWrapper.query(DatabaseHelper.PARTICIPANTS_TABLE,
+ new String[] {ParticipantColumns._ID},
+ ParticipantColumns.SUB_ID + "=?",
+ new String[] { Integer.toString(subId) }, null, null, null);
+ } else {
+ // Look for existing participant with this normalized phone number and no subId.
+ cursor = dbWrapper.query(DatabaseHelper.PARTICIPANTS_TABLE,
+ new String[] {ParticipantColumns._ID},
+ ParticipantColumns.NORMALIZED_DESTINATION + "=? AND "
+ + ParticipantColumns.SUB_ID + "=?",
+ new String[] {canonicalRecipient, Integer.toString(subId)},
+ null, null, null);
+ }
+
+ if (cursor.moveToFirst()) {
+ // TODO Is this assert correct for multi-sim where a new sim was put in?
+ Assert.isTrue(cursor.getCount() == 1);
+
+ // We found an existing participant in the database
+ participantId = cursor.getString(0);
+
+ synchronized (sNormalizedPhoneNumberToParticipantIdCache) {
+ // Add it to the cache for next time
+ sNormalizedPhoneNumberToParticipantIdCache.put(canonicalRecipient,
+ participantId);
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return participantId;
+ }
+
+ @DoesNotRunOnMainThread
+ public static ParticipantData getOrCreateSelf(final DatabaseWrapper dbWrapper,
+ final int subId) {
+ Assert.isNotMainThread();
+ ParticipantData participant = null;
+ dbWrapper.beginTransaction();
+ try {
+ final ParticipantData shell = ParticipantData.getSelfParticipant(subId);
+ final String participantId = getOrCreateParticipantInTransaction(dbWrapper, shell);
+ participant = getExistingParticipant(dbWrapper, participantId);
+ dbWrapper.setTransactionSuccessful();
+ } finally {
+ dbWrapper.endTransaction();
+ }
+ return participant;
+ }
+
+ /**
+ * Lookup and if necessary create a new participant
+ * @param dbWrapper Database wrapper
+ * @param participant Participant to find/create
+ * @return participantId ParticipantId for existing or newly created participant
+ */
+ @DoesNotRunOnMainThread
+ public static String getOrCreateParticipantInTransaction(final DatabaseWrapper dbWrapper,
+ final ParticipantData participant) {
+ Assert.isNotMainThread();
+ Assert.isTrue(dbWrapper.getDatabase().inTransaction());
+ int subId = ParticipantData.OTHER_THAN_SELF_SUB_ID;
+ String participantId = null;
+ String canonicalRecipient = null;
+ if (participant.isSelf()) {
+ subId = participant.getSubId();
+ canonicalRecipient = getCanonicalRecipientFromSubId(subId);
+ } else {
+ canonicalRecipient = participant.getNormalizedDestination();
+ }
+ Assert.notNull(canonicalRecipient);
+ participantId = getParticipantId(dbWrapper, subId, canonicalRecipient);
+
+ if (participantId != null) {
+ return participantId;
+ }
+
+ if (!participant.isContactIdResolved()) {
+ // Refresh participant's name and avatar with matching contact in CP2.
+ ParticipantRefresh.refreshParticipant(dbWrapper, participant);
+ }
+
+ // Insert the participant into the participants table
+ final ContentValues values = participant.toContentValues();
+ final long participantRow = dbWrapper.insert(DatabaseHelper.PARTICIPANTS_TABLE, null,
+ values);
+ participantId = Long.toString(participantRow);
+ Assert.notNull(canonicalRecipient);
+
+ synchronized (sNormalizedPhoneNumberToParticipantIdCache) {
+ // Now that we've inserted it, add it to our cache
+ sNormalizedPhoneNumberToParticipantIdCache.put(canonicalRecipient, participantId);
+ }
+
+ return participantId;
+ }
+
+ @DoesNotRunOnMainThread
+ public static void updateDestination(final DatabaseWrapper dbWrapper,
+ final String destination, final boolean blocked) {
+ Assert.isNotMainThread();
+ final ContentValues values = new ContentValues();
+ values.put(ParticipantColumns.BLOCKED, blocked ? 1 : 0);
+ dbWrapper.update(DatabaseHelper.PARTICIPANTS_TABLE, values,
+ ParticipantColumns.NORMALIZED_DESTINATION + "=? AND " +
+ ParticipantColumns.SUB_ID + "=?",
+ new String[] { destination, Integer.toString(
+ ParticipantData.OTHER_THAN_SELF_SUB_ID) });
+ }
+
+ @DoesNotRunOnMainThread
+ public static String getConversationFromOtherParticipantDestination(
+ final DatabaseWrapper db, final String otherDestination) {
+ Assert.isNotMainThread();
+ Cursor cursor = null;
+ try {
+ cursor = db.query(DatabaseHelper.CONVERSATIONS_TABLE,
+ new String[] { ConversationColumns._ID },
+ ConversationColumns.OTHER_PARTICIPANT_NORMALIZED_DESTINATION + "=?",
+ new String[] { otherDestination }, null, null, null);
+ Assert.inRange(cursor.getCount(), 0, 1);
+ if (cursor.moveToFirst()) {
+ return cursor.getString(0);
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Get a list of conversations that contain any of participants specified.
+ */
+ private static HashSet getConversationsForParticipants(
+ final ArrayList participantIds) {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final HashSet conversationIds = new HashSet();
+
+ final String selection = ConversationParticipantsColumns.PARTICIPANT_ID + "=?";
+ for (final String participantId : participantIds) {
+ final String[] selectionArgs = new String[] { participantId };
+ final Cursor cursor = db.query(DatabaseHelper.CONVERSATION_PARTICIPANTS_TABLE,
+ ConversationParticipantsQuery.PROJECTION,
+ selection, selectionArgs, null, null, null);
+
+ if (cursor != null) {
+ try {
+ while (cursor.moveToNext()) {
+ final String conversationId = cursor.getString(
+ ConversationParticipantsQuery.INDEX_CONVERSATION_ID);
+ conversationIds.add(conversationId);
+ }
+ } finally {
+ cursor.close();
+ }
+ }
+ }
+
+ return conversationIds;
+ }
+
+ /**
+ * Refresh conversation names/avatars based on a list of participants that are changed.
+ */
+ @DoesNotRunOnMainThread
+ public static void refreshConversationsForParticipants(final ArrayList participants) {
+ Assert.isNotMainThread();
+ final HashSet conversationIds = getConversationsForParticipants(participants);
+ if (conversationIds.size() > 0) {
+ for (final String conversationId : conversationIds) {
+ refreshConversation(conversationId);
+ }
+
+ MessagingContentProvider.notifyConversationListChanged();
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Number of conversations refreshed:" + conversationIds.size());
+ }
+ }
+ }
+
+ /**
+ * Refresh conversation names/avatars based on a changed participant.
+ */
+ @DoesNotRunOnMainThread
+ public static void refreshConversationsForParticipant(final String participantId) {
+ Assert.isNotMainThread();
+ final ArrayList participantList = new ArrayList(1);
+ participantList.add(participantId);
+ refreshConversationsForParticipants(participantList);
+ }
+
+ /**
+ * Refresh one conversation.
+ */
+ private static void refreshConversation(final String conversationId) {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ db.beginTransaction();
+ try {
+ BugleDatabaseOperations.updateConversationNameAndAvatarInTransaction(db,
+ conversationId);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+
+ MessagingContentProvider.notifyParticipantsChanged(conversationId);
+ MessagingContentProvider.notifyMessagesChanged(conversationId);
+ MessagingContentProvider.notifyConversationMetadataChanged(conversationId);
+ }
+
+ @DoesNotRunOnMainThread
+ public static boolean updateRowIfExists(final DatabaseWrapper db, final String table,
+ final String rowKey, final String rowId, final ContentValues values) {
+ Assert.isNotMainThread();
+ final StringBuilder sb = new StringBuilder();
+ final ArrayList whereValues = new ArrayList(values.size() + 1);
+ whereValues.add(rowId);
+
+ for (final String key : values.keySet()) {
+ if (sb.length() > 0) {
+ sb.append(" OR ");
+ }
+ final Object value = values.get(key);
+ sb.append(key);
+ if (value != null) {
+ sb.append(" IS NOT ?");
+ whereValues.add(value.toString());
+ } else {
+ sb.append(" IS NOT NULL");
+ }
+ }
+
+ final String whereClause = rowKey + "=?" + " AND (" + sb.toString() + ")";
+ final String [] whereValuesArray = whereValues.toArray(new String[whereValues.size()]);
+ final int count = db.update(table, values, whereClause, whereValuesArray);
+ if (count > 1) {
+ LogUtil.w(LogUtil.BUGLE_TAG, "Updated more than 1 row " + count + "; " + table +
+ " for " + rowKey + " = " + rowId + " (deleted?)");
+ }
+ Assert.inRange(count, 0, 1);
+ return (count >= 0);
+ }
+}
diff --git a/src/com/android/messaging/datamodel/BugleNotifications.java b/src/com/android/messaging/datamodel/BugleNotifications.java
new file mode 100644
index 0000000..b796e73
--- /dev/null
+++ b/src/com/android/messaging/datamodel/BugleNotifications.java
@@ -0,0 +1,1221 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.Config;
+import android.graphics.BitmapFactory;
+import android.graphics.Typeface;
+import android.media.AudioManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+import android.support.v4.app.NotificationCompat;
+import android.support.v4.app.NotificationCompat.WearableExtender;
+import android.support.v4.app.NotificationManagerCompat;
+import android.support.v4.app.RemoteInput;
+import android.support.v4.util.SimpleArrayMap;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.TextUtils;
+import android.text.style.StyleSpan;
+import android.text.style.TextAppearanceSpan;
+
+import com.android.messaging.Factory;
+import com.android.messaging.R;
+import com.android.messaging.datamodel.MessageNotificationState.BundledMessageNotificationState;
+import com.android.messaging.datamodel.MessageNotificationState.ConversationLineInfo;
+import com.android.messaging.datamodel.MessageNotificationState.MultiConversationNotificationState;
+import com.android.messaging.datamodel.MessageNotificationState.MultiMessageNotificationState;
+import com.android.messaging.datamodel.action.MarkAsReadAction;
+import com.android.messaging.datamodel.action.MarkAsSeenAction;
+import com.android.messaging.datamodel.action.RedownloadMmsAction;
+import com.android.messaging.datamodel.data.ConversationListItemData;
+import com.android.messaging.datamodel.media.AvatarRequestDescriptor;
+import com.android.messaging.datamodel.media.ImageResource;
+import com.android.messaging.datamodel.media.MediaRequest;
+import com.android.messaging.datamodel.media.MediaResourceManager;
+import com.android.messaging.datamodel.media.MessagePartVideoThumbnailRequestDescriptor;
+import com.android.messaging.datamodel.media.UriImageRequestDescriptor;
+import com.android.messaging.datamodel.media.VideoThumbnailRequest;
+import com.android.messaging.sms.MmsSmsUtils;
+import com.android.messaging.sms.MmsUtils;
+import com.android.messaging.ui.UIIntents;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.AvatarUriUtil;
+import com.android.messaging.util.BugleGservices;
+import com.android.messaging.util.BugleGservicesKeys;
+import com.android.messaging.util.BuglePrefs;
+import com.android.messaging.util.BuglePrefsKeys;
+import com.android.messaging.util.ContentType;
+import com.android.messaging.util.ConversationIdSet;
+import com.android.messaging.util.ImageUtils;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.NotificationPlayer;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.PendingIntentConstants;
+import com.android.messaging.util.PhoneUtils;
+import com.android.messaging.util.RingtoneUtil;
+import com.android.messaging.util.ThreadUtil;
+import com.android.messaging.util.UriUtil;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * Handle posting, updating and removing all conversation notifications.
+ *
+ * There are currently two main classes of notification and their rules:
+ * 1) Messages - {@link MessageNotificationState}. Only one message notification.
+ * Unread messages across senders and conversations are coalesced.
+ * 2) Failed Messages - {@link MessageNotificationState#checkFailedMesages } Only one failed
+ * message. Multiple failures are coalesced.
+ *
+ * To add a new class of notifications, subclass the NotificationState and add commands which
+ * create one and pass into general creation function.
+ *
+ */
+public class BugleNotifications {
+ // Logging
+ public static final String TAG = LogUtil.BUGLE_NOTIFICATIONS_TAG;
+
+ // Constants to use for update.
+ public static final int UPDATE_NONE = 0;
+ public static final int UPDATE_MESSAGES = 1;
+ public static final int UPDATE_ERRORS = 2;
+ public static final int UPDATE_ALL = UPDATE_MESSAGES + UPDATE_ERRORS;
+
+ // Constants for notification type used for audio and vibration settings.
+ public static final int LOCAL_SMS_NOTIFICATION = 0;
+
+ private static final String SMS_NOTIFICATION_TAG = ":sms:";
+ private static final String SMS_ERROR_NOTIFICATION_TAG = ":error:";
+
+ private static final String WEARABLE_COMPANION_APP_PACKAGE = "com.google.android.wearable.app";
+
+ private static final Set sPendingNotifications =
+ new HashSet();
+
+ private static int sWearableImageWidth;
+ private static int sWearableImageHeight;
+ private static int sIconWidth;
+ private static int sIconHeight;
+
+ private static boolean sInitialized = false;
+
+ private static final Object mLock = new Object();
+
+ // sLastMessageDingTime is a map between a conversation id and a time. It's used to keep track
+ // of the time we last dinged a message for this conversation. When messages are coming in
+ // at flurry, we don't want to over-ding the user.
+ private static final SimpleArrayMap sLastMessageDingTime =
+ new SimpleArrayMap();
+ private static int sTimeBetweenDingsMs;
+
+ /**
+ * This is the volume at which to play the observable-conversation notification sound,
+ * expressed as a fraction of the system notification volume.
+ */
+ private static final float OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME = 0.25f;
+
+ /**
+ * Entry point for posting notifications.
+ * Don't call this on the UI thread.
+ * @param silent If true, no ring will be played. If false, checks global settings before
+ * playing a ringtone
+ * @param coverage Indicates which notification types should be checked. Valid values are
+ * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL
+ */
+ public static void update(final boolean silent, final int coverage) {
+ update(silent, null /* conversationId */, coverage);
+ }
+
+ /**
+ * Entry point for posting notifications.
+ * Don't call this on the UI thread.
+ * @param silent If true, no ring will be played. If false, checks global settings before
+ * playing a ringtone
+ * @param conversationId Conversation ID where a new message was received
+ * @param coverage Indicates which notification types should be checked. Valid values are
+ * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL
+ */
+ public static void update(final boolean silent, final String conversationId,
+ final int coverage) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Update: silent = " + silent
+ + " conversationId = " + conversationId
+ + " coverage = " + coverage);
+ }
+ Assert.isNotMainThread();
+ checkInitialized();
+
+ if (!shouldNotify()) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Notifications disabled");
+ }
+ cancel(PendingIntentConstants.SMS_NOTIFICATION_ID);
+ return;
+ } else {
+ if ((coverage & UPDATE_MESSAGES) != 0) {
+ createMessageNotification(silent, conversationId);
+ }
+ }
+ if ((coverage & UPDATE_ERRORS) != 0) {
+ MessageNotificationState.checkFailedMessages();
+ }
+ }
+
+ /**
+ * Cancel all notifications of a certain type.
+ *
+ * @param type Message or error notifications from Constants.
+ */
+ private static synchronized void cancel(final int type) {
+ cancel(type, null, false);
+ }
+
+ /**
+ * Cancel all notifications of a certain type.
+ *
+ * @param type Message or error notifications from Constants.
+ * @param conversationId If set, cancel the notification for this
+ * conversation only. For message notifications, this only works
+ * if the notifications are bundled (group children).
+ * @param isBundledNotification True if this notification is part of a
+ * notification bundle. This only applies to message notifications,
+ * which are bundled together with other message notifications.
+ */
+ private static synchronized void cancel(final int type, final String conversationId,
+ final boolean isBundledNotification) {
+ final String notificationTag = buildNotificationTag(type, conversationId,
+ isBundledNotification);
+ final NotificationManagerCompat notificationManager =
+ NotificationManagerCompat.from(Factory.get().getApplicationContext());
+
+ // Find all pending notifications and cancel them.
+ synchronized (sPendingNotifications) {
+ final Iterator iter = sPendingNotifications.iterator();
+ while (iter.hasNext()) {
+ final NotificationState notifState = iter.next();
+ if (notifState.mType == type) {
+ notifState.mCanceled = true;
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Canceling pending notification");
+ }
+ iter.remove();
+ }
+ }
+ }
+ notificationManager.cancel(notificationTag, type);
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "Canceled notifications of type " + type);
+ }
+
+ // Message notifications for multiple conversations can be grouped together (see comment in
+ // createMessageNotification). We need to do bookkeeping to track the current set of
+ // notification group children, including removing them when we cancel notifications).
+ if (type == PendingIntentConstants.SMS_NOTIFICATION_ID) {
+ final Context context = Factory.get().getApplicationContext();
+ final ConversationIdSet groupChildIds = getGroupChildIds(context);
+
+ if (groupChildIds != null && groupChildIds.size() > 0) {
+ // If a conversation is specified, remove just that notification. Otherwise,
+ // we're removing the group summary so clear all children.
+ if (conversationId != null) {
+ groupChildIds.remove(conversationId);
+ writeGroupChildIds(context, groupChildIds);
+ } else {
+ cancelStaleGroupChildren(groupChildIds, null);
+ // We'll update the group children preference as we cancel each child,
+ // so we don't need to do it here.
+ }
+ }
+ }
+ }
+
+ /**
+ * Cancels stale notifications from the currently active group of
+ * notifications. If the {@code state} parameter is an instance of
+ * {@link MultiConversationNotificationState} it represents a new
+ * notification group. This method will cancel any notifications that were
+ * in the old group, but not the new one. If the new notification is not a
+ * group, then all existing grouped notifications are cancelled.
+ *
+ * @param previousGroupChildren Conversation ids for the active notification
+ * group
+ * @param state New notification state
+ */
+ private static void cancelStaleGroupChildren(final ConversationIdSet previousGroupChildren,
+ final NotificationState state) {
+ final ConversationIdSet newChildren = new ConversationIdSet();
+ if (state instanceof MultiConversationNotificationState) {
+ for (final NotificationState child :
+ ((MultiConversationNotificationState) state).mChildren) {
+ if (child.mConversationIds != null) {
+ newChildren.add(child.mConversationIds.first());
+ }
+ }
+ }
+ for (final String childConversationId : previousGroupChildren) {
+ if (!newChildren.contains(childConversationId)) {
+ cancel(PendingIntentConstants.SMS_NOTIFICATION_ID, childConversationId, true);
+ }
+ }
+ }
+
+ /**
+ * Returns {@code true} if incoming notifications should display a
+ * notification, {@code false} otherwise.
+ *
+ * @return true if the notification should occur
+ */
+ private static boolean shouldNotify() {
+ // If we're not the default sms app, don't put up any notifications.
+ if (!PhoneUtils.getDefault().isDefaultSmsApp()) {
+ return false;
+ }
+
+ // Now check prefs (i.e. settings) to see if the user turned off notifications.
+ final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+ final Context context = Factory.get().getApplicationContext();
+ final String prefKey = context.getString(R.string.notifications_enabled_pref_key);
+ final boolean defaultValue = context.getResources().getBoolean(
+ R.bool.notifications_enabled_pref_default);
+ return prefs.getBoolean(prefKey, defaultValue);
+ }
+
+ /**
+ * Returns {@code true} if incoming notifications for the given {@link NotificationState}
+ * should vibrate the device, {@code false} otherwise.
+ *
+ * @return true if vibration should be used
+ */
+ public static boolean shouldVibrate(final NotificationState state) {
+ // The notification should vibrate if the global setting is turned on AND
+ // the per-conversation setting is turned on (default).
+ if (!state.getNotificationVibrate()) {
+ return false;
+ } else {
+ final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+ final Context context = Factory.get().getApplicationContext();
+ final String prefKey = context.getString(R.string.notification_vibration_pref_key);
+ final boolean defaultValue = context.getResources().getBoolean(
+ R.bool.notification_vibration_pref_default);
+ return prefs.getBoolean(prefKey, defaultValue);
+ }
+ }
+
+ private static Uri getNotificationRingtoneUriForConversationId(final String conversationId) {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final ConversationListItemData convData =
+ ConversationListItemData.getExistingConversation(db, conversationId);
+ return RingtoneUtil.getNotificationRingtoneUri(
+ convData != null ? convData.getNotificationSoundUri() : null);
+ }
+
+ /**
+ * Returns a unique tag to identify a notification.
+ *
+ * @param name The tag name (in practice, the type)
+ * @param conversationId The conversation id (optional)
+ */
+ private static String buildNotificationTag(final String name,
+ final String conversationId) {
+ final Context context = Factory.get().getApplicationContext();
+ if (conversationId != null) {
+ return context.getPackageName() + name + ":" + conversationId;
+ } else {
+ return context.getPackageName() + name;
+ }
+ }
+
+ /**
+ * Returns a unique tag to identify a notification.
+ *
+ * This delegates to
+ * {@link #buildNotificationTag(int, String, boolean)} and can be
+ * used when the notification is never bundled (e.g. error notifications).
+ */
+ static String buildNotificationTag(final int type, final String conversationId) {
+ return buildNotificationTag(type, conversationId, false /* bundledNotification */);
+ }
+
+ /**
+ * Returns a unique tag to identify a notification.
+ *
+ * @param type One of the constants in {@link PendingIntentConstants}
+ * @param conversationId The conversation id (where applicable)
+ * @param bundledNotification Set to true if this notification will be
+ * bundled together with other notifications (e.g. on a wearable
+ * device).
+ */
+ static String buildNotificationTag(final int type, final String conversationId,
+ final boolean bundledNotification) {
+ String tag = null;
+ switch(type) {
+ case PendingIntentConstants.SMS_NOTIFICATION_ID:
+ if (bundledNotification) {
+ tag = buildNotificationTag(SMS_NOTIFICATION_TAG, conversationId);
+ } else {
+ tag = buildNotificationTag(SMS_NOTIFICATION_TAG, null);
+ }
+ break;
+ case PendingIntentConstants.MSG_SEND_ERROR:
+ tag = buildNotificationTag(SMS_ERROR_NOTIFICATION_TAG, null);
+ break;
+ }
+ return tag;
+ }
+
+ private static void checkInitialized() {
+ if (!sInitialized) {
+ final Resources resources = Factory.get().getApplicationContext().getResources();
+ sWearableImageWidth = resources.getDimensionPixelSize(
+ R.dimen.notification_wearable_image_width);
+ sWearableImageHeight = resources.getDimensionPixelSize(
+ R.dimen.notification_wearable_image_height);
+ sIconHeight = (int) resources.getDimension(
+ android.R.dimen.notification_large_icon_height);
+ sIconWidth =
+ (int) resources.getDimension(android.R.dimen.notification_large_icon_width);
+
+ sInitialized = true;
+ }
+ }
+
+ private static void processAndSend(final NotificationState state, final boolean silent,
+ final boolean softSound) {
+ final Context context = Factory.get().getApplicationContext();
+ final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context);
+ notifBuilder.setCategory(Notification.CATEGORY_MESSAGE);
+ // TODO: Need to fix this for multi conversation notifications to rate limit dings.
+ final String conversationId = state.mConversationIds.first();
+
+
+ final Uri ringtoneUri = RingtoneUtil.getNotificationRingtoneUri(state.getRingtoneUri());
+ // If the notification's conversation is currently observable (focused or in the
+ // conversation list), then play a notification beep at a low volume and don't display an
+ // actual notification.
+ if (softSound) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "processAndSend: fromConversationId == " +
+ "sCurrentlyDisplayedConversationId so NOT showing notification," +
+ " but playing soft sound. conversationId: " + conversationId);
+ }
+ playObservableConversationNotificationSound(ringtoneUri);
+ return;
+ }
+ state.mBaseRequestCode = state.mType;
+
+ // Set the delete intent (except for bundled wearable notifications, which are dismissed
+ // as a group, either from the wearable or when the summary notification is dismissed from
+ // the host device).
+ if (!(state instanceof BundledMessageNotificationState)) {
+ final PendingIntent clearIntent = state.getClearIntent();
+ notifBuilder.setDeleteIntent(clearIntent);
+ }
+
+ updateBuilderAudioVibrate(state, notifBuilder, silent, ringtoneUri, conversationId);
+
+ // Set the content intent
+ PendingIntent destinationIntent;
+ if (state.mConversationIds.size() > 1) {
+ // We have notifications for multiple conversation, go to the conversation list.
+ destinationIntent = UIIntents.get()
+ .getPendingIntentForConversationListActivity(context);
+ } else {
+ // We have a single conversation, go directly to that conversation.
+ destinationIntent = UIIntents.get()
+ .getPendingIntentForConversationActivity(context,
+ state.mConversationIds.first(),
+ null /*draft*/);
+ }
+ notifBuilder.setContentIntent(destinationIntent);
+
+ // TODO: set based on contact coming from a favorite.
+ notifBuilder.setPriority(state.getPriority());
+
+ // Save the state of the notification in-progress so when the avatar is loaded,
+ // we can continue building the notification.
+ final NotificationCompat.Style notifStyle = state.build(notifBuilder);
+ state.mNotificationBuilder = notifBuilder;
+ state.mNotificationStyle = notifStyle;
+ if (!state.mPeople.isEmpty()) {
+ final Bundle people = new Bundle();
+ people.putStringArray(NotificationCompat.EXTRA_PEOPLE,
+ state.mPeople.toArray(new String[state.mPeople.size()]));
+ notifBuilder.addExtras(people);
+ }
+
+ if (state.mParticipantAvatarsUris != null) {
+ final Uri avatarUri = state.mParticipantAvatarsUris.get(0);
+ final AvatarRequestDescriptor descriptor = new AvatarRequestDescriptor(avatarUri,
+ sIconWidth, sIconHeight, OsUtil.isAtLeastL());
+ final MediaRequest imageRequest = descriptor.buildSyncMediaRequest(
+ context);
+
+ synchronized (sPendingNotifications) {
+ sPendingNotifications.add(state);
+ }
+
+ // Synchronously load the avatar.
+ final ImageResource avatarImage =
+ MediaResourceManager.get().requestMediaResourceSync(imageRequest);
+ if (avatarImage != null) {
+ ImageResource avatarHiRes = null;
+ try {
+ if (isWearCompanionAppInstalled()) {
+ // For Wear users, we need to request a high-res avatar image to use as the
+ // notification card background. If the sender has a contact photo, we'll
+ // request the display photo from the Contacts provider. Otherwise, we ask
+ // the local content provider for a hi-res version of the generic avatar
+ // (e.g. letter with colored background).
+ avatarHiRes = requestContactDisplayPhoto(context,
+ getDisplayPhotoUri(avatarUri));
+ if (avatarHiRes == null) {
+ final AvatarRequestDescriptor hiResDesc =
+ new AvatarRequestDescriptor(avatarUri,
+ sWearableImageWidth,
+ sWearableImageHeight,
+ false /* cropToCircle */,
+ true /* isWearBackground */);
+ avatarHiRes = MediaResourceManager.get().requestMediaResourceSync(
+ hiResDesc.buildSyncMediaRequest(context));
+ }
+ }
+
+ // We have to make copies of the bitmaps to hand to the NotificationManager
+ // because the bitmap in the ImageResource is managed and will automatically
+ // get released.
+ Bitmap avatarBitmap = Bitmap.createBitmap(avatarImage.getBitmap());
+ Bitmap avatarHiResBitmap = (avatarHiRes != null) ?
+ Bitmap.createBitmap(avatarHiRes.getBitmap()) : null;
+ sendNotification(state, avatarBitmap, avatarHiResBitmap);
+ return;
+ } finally {
+ avatarImage.release();
+ if (avatarHiRes != null) {
+ avatarHiRes.release();
+ }
+ }
+ }
+ }
+ // We have no avatar. Post the notification anyway.
+ sendNotification(state, null, null);
+ }
+
+ /**
+ * Returns the thumbnailUri from the avatar URI, or null if avatar URI does not have thumbnail.
+ */
+ private static Uri getThumbnailUri(final Uri avatarUri) {
+ Uri localUri = null;
+ final String avatarType = AvatarUriUtil.getAvatarType(avatarUri);
+ if (TextUtils.equals(avatarType, AvatarUriUtil.TYPE_LOCAL_RESOURCE_URI)) {
+ localUri = AvatarUriUtil.getPrimaryUri(avatarUri);
+ } else if (UriUtil.isLocalResourceUri(avatarUri)) {
+ localUri = avatarUri;
+ }
+ if (localUri != null && localUri.getAuthority().equals(ContactsContract.AUTHORITY)) {
+ // Contact photos are of the form: content://com.android.contacts/contacts/123/photo
+ final List pathParts = localUri.getPathSegments();
+ if (pathParts.size() == 3 &&
+ pathParts.get(2).equals(Contacts.Photo.CONTENT_DIRECTORY)) {
+ return localUri;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the displayPhotoUri from the avatar URI, or null if avatar URI
+ * does not have a displayPhotoUri.
+ */
+ private static Uri getDisplayPhotoUri(final Uri avatarUri) {
+ final Uri thumbnailUri = getThumbnailUri(avatarUri);
+ if (thumbnailUri == null) {
+ return null;
+ }
+ final List originalPaths = thumbnailUri.getPathSegments();
+ final int originalPathsSize = originalPaths.size();
+ final StringBuilder newPathBuilder = new StringBuilder();
+ // Change content://com.android.contacts/contacts("_corp")/123/photo to
+ // content://com.android.contacts/contacts("_corp")/123/display_photo
+ for (int i = 0; i < originalPathsSize; i++) {
+ newPathBuilder.append('/');
+ if (i == 2) {
+ newPathBuilder.append(ContactsContract.Contacts.Photo.DISPLAY_PHOTO);
+ } else {
+ newPathBuilder.append(originalPaths.get(i));
+ }
+ }
+ return thumbnailUri.buildUpon().path(newPathBuilder.toString()).build();
+ }
+
+ private static ImageResource requestContactDisplayPhoto(final Context context,
+ final Uri displayPhotoUri) {
+ final UriImageRequestDescriptor bgDescriptor =
+ new UriImageRequestDescriptor(displayPhotoUri,
+ sWearableImageWidth,
+ sWearableImageHeight,
+ false, /* allowCompression */
+ true, /* isStatic */
+ false /* cropToCircle */,
+ ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */,
+ ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */);
+ return MediaResourceManager.get().requestMediaResourceSync(
+ bgDescriptor.buildSyncMediaRequest(context));
+ }
+
+ private static void createMessageNotification(final boolean silent,
+ final String conversationId) {
+ final NotificationState state = MessageNotificationState.getNotificationState();
+ final boolean softSound = DataModel.get().isNewMessageObservable(conversationId);
+ if (state == null) {
+ cancel(PendingIntentConstants.SMS_NOTIFICATION_ID);
+ if (softSound && !TextUtils.isEmpty(conversationId)) {
+ final Uri ringtoneUri = getNotificationRingtoneUriForConversationId(conversationId);
+ playObservableConversationNotificationSound(ringtoneUri);
+ }
+ return;
+ }
+ processAndSend(state, silent, softSound);
+
+ // The rest of the logic here is for supporting Android Wear devices, specifically for when
+ // we are notifying about multiple conversations. In that case, the Inbox-style summary
+ // notification (which we already processed above) appears on the phone (as it always has),
+ // but wearables show per-conversation notifications, bundled together in a group.
+
+ // It is valid to replace a notification group with another group with fewer conversations,
+ // or even with one notification for a single conversation. In either case, we need to
+ // explicitly cancel any children from the old group which are not being notified about now.
+ final Context context = Factory.get().getApplicationContext();
+ final ConversationIdSet oldGroupChildIds = getGroupChildIds(context);
+ if (oldGroupChildIds != null && oldGroupChildIds.size() > 0) {
+ cancelStaleGroupChildren(oldGroupChildIds, state);
+ }
+
+ // Send per-conversation notifications (if there are multiple conversations).
+ final ConversationIdSet groupChildIds = new ConversationIdSet();
+ if (state instanceof MultiConversationNotificationState) {
+ for (final NotificationState child :
+ ((MultiConversationNotificationState) state).mChildren) {
+ processAndSend(child, true /* silent */, softSound);
+ if (child.mConversationIds != null) {
+ groupChildIds.add(child.mConversationIds.first());
+ }
+ }
+ }
+
+ // Record the new set of group children.
+ writeGroupChildIds(context, groupChildIds);
+ }
+
+ private static void updateBuilderAudioVibrate(final NotificationState state,
+ final NotificationCompat.Builder notifBuilder, final boolean silent,
+ final Uri ringtoneUri, final String conversationId) {
+ int defaults = Notification.DEFAULT_LIGHTS;
+ if (!silent) {
+ final BuglePrefs prefs = Factory.get().getApplicationPrefs();
+ final long latestNotificationTimestamp = prefs.getLong(
+ BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP, Long.MIN_VALUE);
+ final long latestReceivedTimestamp = state.getLatestReceivedTimestamp();
+ prefs.putLong(
+ BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP,
+ Math.max(latestNotificationTimestamp, latestReceivedTimestamp));
+ if (latestReceivedTimestamp > latestNotificationTimestamp) {
+ synchronized (mLock) {
+ // Find out the last time we dinged for this conversation
+ Long lastTime = sLastMessageDingTime.get(conversationId);
+ if (sTimeBetweenDingsMs == 0) {
+ sTimeBetweenDingsMs = BugleGservices.get().getInt(
+ BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS,
+ BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS_DEFAULT) *
+ 1000;
+ }
+ if (lastTime == null
+ || SystemClock.elapsedRealtime() - lastTime > sTimeBetweenDingsMs) {
+ sLastMessageDingTime.put(conversationId, SystemClock.elapsedRealtime());
+ notifBuilder.setSound(ringtoneUri);
+ if (shouldVibrate(state)) {
+ defaults |= Notification.DEFAULT_VIBRATE;
+ }
+ }
+ }
+ }
+ }
+ notifBuilder.setDefaults(defaults);
+ }
+
+ // TODO: this doesn't seem to be defined in NotificationCompat yet. Temporarily
+ // define it here until it makes its way from Notification -> NotificationCompat.
+ /**
+ * Notification category: incoming direct message (SMS, instant message, etc.).
+ */
+ private static final String CATEGORY_MESSAGE = "msg";
+
+ private static void sendNotification(final NotificationState notificationState,
+ final Bitmap avatarIcon, final Bitmap avatarHiRes) {
+ final Context context = Factory.get().getApplicationContext();
+ if (notificationState.mCanceled) {
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "sendNotification: Notification already cancelled; dropping it");
+ }
+ return;
+ }
+
+ synchronized (sPendingNotifications) {
+ if (sPendingNotifications.contains(notificationState)) {
+ sPendingNotifications.remove(notificationState);
+ }
+ }
+
+ notificationState.mNotificationBuilder
+ .setSmallIcon(notificationState.getIcon())
+ .setVisibility(NotificationCompat.VISIBILITY_PRIVATE)
+ .setColor(context.getResources().getColor(R.color.notification_accent_color))
+// .setPublicVersion(null) // TODO: when/if we ever support different
+ // text on the lockscreen, instead of "contents hidden"
+ .setCategory(CATEGORY_MESSAGE);
+
+ if (avatarIcon != null) {
+ notificationState.mNotificationBuilder.setLargeIcon(avatarIcon);
+ }
+
+ if (notificationState.mParticipantContactUris != null &&
+ notificationState.mParticipantContactUris.size() > 0) {
+ for (final Uri contactUri : notificationState.mParticipantContactUris) {
+ notificationState.mNotificationBuilder.addPerson(contactUri.toString());
+ }
+ }
+
+ final Uri attachmentUri = notificationState.getAttachmentUri();
+ final String attachmentType = notificationState.getAttachmentType();
+ Bitmap attachmentBitmap = null;
+
+ // For messages with photo/video attachment, request an image to show in the notification.
+ if (attachmentUri != null && notificationState.mNotificationStyle != null &&
+ (notificationState.mNotificationStyle instanceof
+ NotificationCompat.BigPictureStyle) &&
+ (ContentType.isImageType(attachmentType) ||
+ ContentType.isVideoType(attachmentType))) {
+ final boolean isVideo = ContentType.isVideoType(attachmentType);
+
+ MediaRequest imageRequest;
+ if (isVideo) {
+ Assert.isTrue(VideoThumbnailRequest.shouldShowIncomingVideoThumbnails());
+ final MessagePartVideoThumbnailRequestDescriptor videoDescriptor =
+ new MessagePartVideoThumbnailRequestDescriptor(attachmentUri);
+ imageRequest = videoDescriptor.buildSyncMediaRequest(context);
+ } else {
+ final UriImageRequestDescriptor imageDescriptor =
+ new UriImageRequestDescriptor(attachmentUri,
+ sWearableImageWidth,
+ sWearableImageHeight,
+ false /* allowCompression */,
+ true /* isStatic */,
+ false /* cropToCircle */,
+ ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */,
+ ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */);
+ imageRequest = imageDescriptor.buildSyncMediaRequest(context);
+ }
+ final ImageResource imageResource =
+ MediaResourceManager.get().requestMediaResourceSync(imageRequest);
+ if (imageResource != null) {
+ try {
+ // Copy the bitmap, because the one in the ImageResource is managed by
+ // MediaResourceManager.
+ Bitmap imageResourceBitmap = imageResource.getBitmap();
+ Config config = imageResourceBitmap.getConfig();
+
+ // Make sure our bitmap has a valid format.
+ if (config == null) {
+ config = Bitmap.Config.ARGB_8888;
+ }
+ attachmentBitmap = imageResourceBitmap.copy(config, true);
+ } finally {
+ imageResource.release();
+ }
+ }
+ }
+
+ fireOffNotification(notificationState, attachmentBitmap, avatarIcon, avatarHiRes);
+ }
+
+ private static void fireOffNotification(final NotificationState notificationState,
+ final Bitmap attachmentBitmap, final Bitmap avatarBitmap, Bitmap avatarHiResBitmap) {
+ if (notificationState.mCanceled) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Firing off notification, but notification already canceled");
+ }
+ return;
+ }
+
+ final Context context = Factory.get().getApplicationContext();
+
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "MMS picture loaded, bitmap: " + attachmentBitmap);
+ }
+
+ final NotificationCompat.Builder notifBuilder = notificationState.mNotificationBuilder;
+ notifBuilder.setStyle(notificationState.mNotificationStyle);
+ notifBuilder.setColor(context.getResources().getColor(R.color.notification_accent_color));
+
+ final WearableExtender wearableExtender = new WearableExtender();
+ setWearableGroupOptions(notifBuilder, notificationState);
+
+ if (avatarHiResBitmap != null) {
+ wearableExtender.setBackground(avatarHiResBitmap);
+ } else if (avatarBitmap != null) {
+ // Nothing to do here; we already set avatarBitmap as the notification icon
+ } else {
+ final Bitmap defaultBackground = BitmapFactory.decodeResource(
+ context.getResources(), R.drawable.bg_sms);
+ wearableExtender.setBackground(defaultBackground);
+ }
+
+ if (notificationState instanceof MultiMessageNotificationState) {
+ if (attachmentBitmap != null) {
+ // When we've got a picture attachment, we do some switcheroo trickery. When
+ // the notification is expanded, we show the picture as a bigPicture. The small
+ // icon shows the sender's avatar. When that same notification is collapsed, the
+ // picture is shown in the location where the avatar is normally shown. The lines
+ // below make all that happen.
+
+ // Here we're taking the picture attachment and making a small, scaled, center
+ // cropped version of the picture we can stuff into the place where the avatar
+ // goes when the notification is collapsed.
+ final Bitmap smallBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap, sIconWidth,
+ sIconHeight);
+ ((NotificationCompat.BigPictureStyle) notificationState.mNotificationStyle)
+ .bigPicture(attachmentBitmap)
+ .bigLargeIcon(avatarBitmap);
+ notificationState.mNotificationBuilder.setLargeIcon(smallBitmap);
+
+ // Add a wearable page with no visible card so you can more easily see the photo.
+ final NotificationCompat.Builder photoPageNotifBuilder =
+ new NotificationCompat.Builder(Factory.get().getApplicationContext());
+ final WearableExtender photoPageWearableExtender = new WearableExtender();
+ photoPageWearableExtender.setHintShowBackgroundOnly(true);
+ if (attachmentBitmap != null) {
+ final Bitmap wearBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap,
+ sWearableImageWidth, sWearableImageHeight);
+ photoPageWearableExtender.setBackground(wearBitmap);
+ }
+ photoPageNotifBuilder.extend(photoPageWearableExtender);
+ wearableExtender.addPage(photoPageNotifBuilder.build());
+ }
+
+ maybeAddWearableConversationLog(wearableExtender,
+ (MultiMessageNotificationState) notificationState);
+ addDownloadMmsAction(notifBuilder, wearableExtender, notificationState);
+ addWearableVoiceReplyAction(wearableExtender, notificationState);
+ }
+
+ // Apply the wearable options and build & post the notification
+ notifBuilder.extend(wearableExtender);
+ doNotify(notifBuilder.build(), notificationState);
+ }
+
+ private static void setWearableGroupOptions(final NotificationCompat.Builder notifBuilder,
+ final NotificationState notificationState) {
+ final String groupKey = "groupkey";
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Group key (for wearables)=" + groupKey);
+ }
+ if (notificationState instanceof MultiConversationNotificationState) {
+ notifBuilder.setGroup(groupKey).setGroupSummary(true);
+ } else if (notificationState instanceof BundledMessageNotificationState) {
+ final int order = ((BundledMessageNotificationState) notificationState).mGroupOrder;
+ // Convert the order to a zero-padded string ("00", "01", "02", etc).
+ // The Wear library orders notifications within a bundle lexicographically
+ // by the sort key, hence the need for zeroes to preserve the ordering.
+ final String sortKey = String.format(Locale.US, "%02d", order);
+ notifBuilder.setGroup(groupKey).setSortKey(sortKey);
+ }
+ }
+
+ private static void maybeAddWearableConversationLog(
+ final WearableExtender wearableExtender,
+ final MultiMessageNotificationState notificationState) {
+ if (!isWearCompanionAppInstalled()) {
+ return;
+ }
+ final String convId = notificationState.mConversationIds.first();
+ ConversationLineInfo convInfo = notificationState.mConvList.mConvInfos.get(0);
+ final Notification page = MessageNotificationState.buildConversationPageForWearable(
+ convId,
+ convInfo.mParticipantCount);
+ if (page != null) {
+ wearableExtender.addPage(page);
+ }
+ }
+
+ private static void addWearableVoiceReplyAction(
+ final WearableExtender wearableExtender, final NotificationState notificationState) {
+ if (!(notificationState instanceof MultiMessageNotificationState)) {
+ return;
+ }
+ final MultiMessageNotificationState multiMessageNotificationState =
+ (MultiMessageNotificationState) notificationState;
+ final Context context = Factory.get().getApplicationContext();
+
+ final String conversationId = notificationState.mConversationIds.first();
+ final ConversationLineInfo convInfo =
+ multiMessageNotificationState.mConvList.mConvInfos.get(0);
+ final String selfId = convInfo.mSelfParticipantId;
+
+ final boolean requiresMms =
+ MmsSmsUtils.getRequireMmsForEmailAddress(
+ convInfo.mIncludeEmailAddress, convInfo.mSubId) ||
+ (convInfo.mIsGroup && MmsUtils.groupMmsEnabled(convInfo.mSubId));
+
+ final int requestCode = multiMessageNotificationState.getReplyIntentRequestCode();
+ final PendingIntent replyPendingIntent = UIIntents.get()
+ .getPendingIntentForSendingMessageToConversation(context,
+ conversationId, selfId, requiresMms, requestCode);
+
+ final int replyLabelRes = requiresMms ? R.string.notification_reply_via_mms :
+ R.string.notification_reply_via_sms;
+
+ final NotificationCompat.Action.Builder actionBuilder =
+ new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply,
+ context.getString(replyLabelRes), replyPendingIntent);
+ final String[] choices = context.getResources().getStringArray(
+ R.array.notification_reply_choices);
+ final RemoteInput remoteInput = new RemoteInput.Builder(Intent.EXTRA_TEXT).setLabel(
+ context.getString(R.string.notification_reply_prompt)).
+ setChoices(choices)
+ .build();
+ actionBuilder.addRemoteInput(remoteInput);
+ wearableExtender.addAction(actionBuilder.build());
+ }
+
+ private static void addDownloadMmsAction(final NotificationCompat.Builder notifBuilder,
+ final WearableExtender wearableExtender, final NotificationState notificationState) {
+ if (!(notificationState instanceof MultiMessageNotificationState)) {
+ return;
+ }
+ final MultiMessageNotificationState multiMessageNotificationState =
+ (MultiMessageNotificationState) notificationState;
+ final ConversationLineInfo convInfo =
+ multiMessageNotificationState.mConvList.mConvInfos.get(0);
+ if (!convInfo.getDoesLatestMessageNeedDownload()) {
+ return;
+ }
+ final String messageId = convInfo.getLatestMessageId();
+ if (messageId == null) {
+ // No message Id, no download for you
+ return;
+ }
+ final Context context = Factory.get().getApplicationContext();
+ final PendingIntent downloadPendingIntent =
+ RedownloadMmsAction.getPendingIntentForRedownloadMms(context, messageId);
+
+ final NotificationCompat.Action.Builder actionBuilder =
+ new NotificationCompat.Action.Builder(R.drawable.ic_file_download_light,
+ context.getString(R.string.notification_download_mms),
+ downloadPendingIntent);
+ final NotificationCompat.Action downloadAction = actionBuilder.build();
+ notifBuilder.addAction(downloadAction);
+
+ // Support the action on a wearable device as well
+ wearableExtender.addAction(downloadAction);
+ }
+
+ private static synchronized void doNotify(final Notification notification,
+ final NotificationState notificationState) {
+ if (notification == null) {
+ return;
+ }
+ final int type = notificationState.mType;
+ final ConversationIdSet conversationIds = notificationState.mConversationIds;
+ final boolean isBundledNotification =
+ (notificationState instanceof BundledMessageNotificationState);
+
+ // Mark the notification as finished
+ notificationState.mCanceled = true;
+
+ final NotificationManagerCompat notificationManager =
+ NotificationManagerCompat.from(Factory.get().getApplicationContext());
+ // Only need conversationId for tags with a single conversation.
+ String conversationId = null;
+ if (conversationIds != null && conversationIds.size() == 1) {
+ conversationId = conversationIds.first();
+ }
+ final String notificationTag = buildNotificationTag(type,
+ conversationId, isBundledNotification);
+
+ notification.flags |= Notification.FLAG_AUTO_CANCEL;
+ notification.defaults |= Notification.DEFAULT_LIGHTS;
+
+ notificationManager.notify(notificationTag, type, notification);
+
+ LogUtil.i(TAG, "Notifying for conversation " + conversationId + "; "
+ + "tag = " + notificationTag + ", type = " + type);
+ }
+
+ // This is the message string used in each line of an inboxStyle notification.
+ // TODO: add attachment type
+ static CharSequence formatInboxMessage(final String sender,
+ final CharSequence message, final Uri attachmentUri, final String attachmentType) {
+ final Context context = Factory.get().getApplicationContext();
+ final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan(
+ context, R.style.NotificationSenderText);
+
+ final TextAppearanceSpan notificationTertiaryText = new TextAppearanceSpan(
+ context, R.style.NotificationTertiaryText);
+
+ final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
+ if (!TextUtils.isEmpty(sender)) {
+ spannableStringBuilder.append(sender);
+ spannableStringBuilder.setSpan(notificationSenderSpan, 0, sender.length(), 0);
+ }
+ final String separator = context.getString(R.string.notification_separator);
+
+ if (!TextUtils.isEmpty(message)) {
+ if (spannableStringBuilder.length() > 0) {
+ spannableStringBuilder.append(separator);
+ }
+ final int start = spannableStringBuilder.length();
+ spannableStringBuilder.append(message);
+ spannableStringBuilder.setSpan(notificationTertiaryText, start,
+ start + message.length(), 0);
+ }
+ if (attachmentUri != null) {
+ if (spannableStringBuilder.length() > 0) {
+ spannableStringBuilder.append(separator);
+ }
+ spannableStringBuilder.append(formatAttachmentTag(null, attachmentType));
+ }
+ return spannableStringBuilder;
+ }
+
+ protected static CharSequence buildColonSeparatedMessage(
+ final String title, final CharSequence content, final Uri attachmentUri,
+ final String attachmentType) {
+ return buildBoldedMessage(title, content, attachmentUri, attachmentType,
+ R.string.notification_ticker_separator);
+ }
+
+ protected static CharSequence buildSpaceSeparatedMessage(
+ final String title, final CharSequence content, final Uri attachmentUri,
+ final String attachmentType) {
+ return buildBoldedMessage(title, content, attachmentUri, attachmentType,
+ R.string.notification_space_separator);
+ }
+
+ /**
+ * buildBoldedMessage - build a formatted message where the title is bold, there's a
+ * separator, then the message.
+ */
+ private static CharSequence buildBoldedMessage(
+ final String title, final CharSequence message, final Uri attachmentUri,
+ final String attachmentType,
+ final int separatorId) {
+ final Context context = Factory.get().getApplicationContext();
+ final SpannableStringBuilder spanBuilder = new SpannableStringBuilder();
+
+ // Boldify the title (which is the sender's name)
+ if (!TextUtils.isEmpty(title)) {
+ spanBuilder.append(title);
+ spanBuilder.setSpan(new StyleSpan(Typeface.BOLD), 0, title.length(),
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ if (!TextUtils.isEmpty(message)) {
+ if (spanBuilder.length() > 0) {
+ spanBuilder.append(context.getString(separatorId));
+ }
+ spanBuilder.append(message);
+ }
+ if (attachmentUri != null) {
+ if (spanBuilder.length() > 0) {
+ final String separator = context.getString(R.string.notification_separator);
+ spanBuilder.append(separator);
+ }
+ spanBuilder.append(formatAttachmentTag(null, attachmentType));
+ }
+ return spanBuilder;
+ }
+
+ static CharSequence formatAttachmentTag(final String author, final String attachmentType) {
+ final Context context = Factory.get().getApplicationContext();
+ final TextAppearanceSpan notificationSecondaryText = new TextAppearanceSpan(
+ context, R.style.NotificationSecondaryText);
+ final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
+ if (!TextUtils.isEmpty(author)) {
+ final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan(
+ context, R.style.NotificationSenderText);
+ spannableStringBuilder.append(author);
+ spannableStringBuilder.setSpan(notificationSenderSpan, 0, author.length(), 0);
+ final String separator = context.getString(R.string.notification_separator);
+ spannableStringBuilder.append(separator);
+ }
+ final int start = spannableStringBuilder.length();
+ // The default attachment type is an image, since that's what was originally
+ // supported. When there's no content type, assume it's an image.
+ int message = R.string.notification_picture;
+ if (ContentType.isAudioType(attachmentType)) {
+ message = R.string.notification_audio;
+ } else if (ContentType.isVideoType(attachmentType)) {
+ message = R.string.notification_video;
+ } else if (ContentType.isVCardType(attachmentType)) {
+ message = R.string.notification_vcard;
+ }
+ spannableStringBuilder.append(context.getText(message));
+ spannableStringBuilder.setSpan(notificationSecondaryText, start,
+ spannableStringBuilder.length(), 0);
+ return spannableStringBuilder;
+ }
+
+ /**
+ * Play the observable conversation notification sound (it's the regular notification sound, but
+ * played at half-volume)
+ */
+ private static void playObservableConversationNotificationSound(final Uri ringtoneUri) {
+ final Context context = Factory.get().getApplicationContext();
+ final AudioManager audioManager = (AudioManager) context
+ .getSystemService(Context.AUDIO_SERVICE);
+ final boolean silenced =
+ audioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL;
+ if (silenced) {
+ return;
+ }
+
+ final NotificationPlayer player = new NotificationPlayer(LogUtil.BUGLE_TAG);
+ player.play(ringtoneUri, false,
+ AudioManager.STREAM_NOTIFICATION,
+ OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME);
+
+ // Stop the sound after five seconds to handle continuous ringtones
+ ThreadUtil.getMainThreadHandler().postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ player.stop();
+ }
+ }, 5000);
+ }
+
+ public static boolean isWearCompanionAppInstalled() {
+ boolean found = false;
+ try {
+ Factory.get().getApplicationContext().getPackageManager()
+ .getPackageInfo(WEARABLE_COMPANION_APP_PACKAGE, 0);
+ found = true;
+ } catch (final NameNotFoundException e) {
+ // Ignore; found is already false
+ }
+ return found;
+ }
+
+ /**
+ * When we go to the conversation list, call this to mark all messages as seen. That means
+ * we won't show a notification again for the same message.
+ */
+ public static void markAllMessagesAsSeen() {
+ MarkAsSeenAction.markAllAsSeen();
+ resetLastMessageDing(null); // reset the ding timeout for all conversations
+ }
+
+ /**
+ * When we open a particular conversation, call this to mark all messages as read.
+ */
+ public static void markMessagesAsRead(final String conversationId) {
+ MarkAsReadAction.markAsRead(conversationId);
+ resetLastMessageDing(conversationId);
+ }
+
+ /**
+ * Returns the conversation ids of all active, grouped notifications, or
+ * {code null} if no notifications are currently active and grouped.
+ */
+ private static ConversationIdSet getGroupChildIds(final Context context) {
+ final String prefKey = context.getString(R.string.notifications_group_children_key);
+ final String groupChildIdsText = BuglePrefs.getApplicationPrefs().getString(prefKey, "");
+ if (!TextUtils.isEmpty(groupChildIdsText)) {
+ return ConversationIdSet.createSet(groupChildIdsText);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Records the conversation ids of the currently active grouped notifications.
+ */
+ private static void writeGroupChildIds(final Context context,
+ final ConversationIdSet childIds) {
+ final ConversationIdSet oldChildIds = getGroupChildIds(context);
+ if (childIds.equals(oldChildIds)) {
+ return;
+ }
+ final String prefKey = context.getString(R.string.notifications_group_children_key);
+ BuglePrefs.getApplicationPrefs().putString(prefKey, childIds.getDelimitedString());
+ }
+
+ /**
+ * Reset the timer for a notification ding on a particular conversation or all conversations.
+ */
+ public static void resetLastMessageDing(final String conversationId) {
+ synchronized (mLock) {
+ if (TextUtils.isEmpty(conversationId)) {
+ // reset all conversation dings
+ sLastMessageDingTime.clear();
+ } else {
+ sLastMessageDingTime.remove(conversationId);
+ }
+ }
+ }
+
+ public static void notifyEmergencySmsFailed(final String emergencyNumber,
+ final String conversationId) {
+ final Context context = Factory.get().getApplicationContext();
+
+ final CharSequence line1 = MessageNotificationState.applyWarningTextColor(context,
+ context.getString(R.string.notification_emergency_send_failure_line1,
+ emergencyNumber));
+ final String line2 = context.getString(R.string.notification_emergency_send_failure_line2,
+ emergencyNumber);
+ final PendingIntent destinationIntent = UIIntents.get()
+ .getPendingIntentForConversationActivity(context, conversationId, null /* draft */);
+
+ final NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
+ builder.setTicker(line1)
+ .setContentTitle(line1)
+ .setContentText(line2)
+ .setStyle(new NotificationCompat.BigTextStyle(builder).bigText(line2))
+ .setSmallIcon(R.drawable.ic_failed_light)
+ .setContentIntent(destinationIntent)
+ .setSound(UriUtil.getUriForResourceId(context, R.raw.message_failure));
+
+ final String tag = context.getPackageName() + ":emergency_sms_error";
+ NotificationManagerCompat.from(context).notify(
+ tag,
+ PendingIntentConstants.MSG_SEND_ERROR,
+ builder.build());
+ }
+}
+
diff --git a/src/com/android/messaging/datamodel/BugleRecipientEntry.java b/src/com/android/messaging/datamodel/BugleRecipientEntry.java
new file mode 100644
index 0000000..2a9e5ff
--- /dev/null
+++ b/src/com/android/messaging/datamodel/BugleRecipientEntry.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.android.ex.chips.RecipientEntry;
+
+/**
+ * An extension of RecipientEntry for Bugle's use since Bugle uses phone numbers to identify
+ * participants / recipients instead of contact ids. This allows the user to send to multiple
+ * phone numbers of the same contact.
+ */
+public class BugleRecipientEntry extends RecipientEntry {
+
+ protected BugleRecipientEntry(final int entryType, final String displayName,
+ final String destination, final int destinationType, final String destinationLabel,
+ final long contactId, final Long directoryId, final long dataId,
+ final Uri photoThumbnailUri, final boolean isFirstLevel, final boolean isValid,
+ final String lookupKey) {
+ super(entryType, displayName, destination, destinationType, destinationLabel, contactId,
+ directoryId, dataId, photoThumbnailUri, isFirstLevel, isValid, lookupKey);
+ }
+
+ public static BugleRecipientEntry constructTopLevelEntry(final String displayName,
+ final int displayNameSource, final String destination, final int destinationType,
+ final String destinationLabel, final long contactId, final Long directoryId,
+ final long dataId, final String thumbnailUriAsString, final boolean isValid,
+ final String lookupKey) {
+ return new BugleRecipientEntry(ENTRY_TYPE_PERSON, displayName, destination, destinationType,
+ destinationLabel, contactId, directoryId, dataId, (thumbnailUriAsString != null
+ ? Uri.parse(thumbnailUriAsString) : null), true, isValid, lookupKey);
+ }
+
+ public static BugleRecipientEntry constructSecondLevelEntry(final String displayName,
+ final int displayNameSource, final String destination, final int destinationType,
+ final String destinationLabel, final long contactId, final Long directoryId,
+ final long dataId, final String thumbnailUriAsString, final boolean isValid,
+ final String lookupKey) {
+ return new BugleRecipientEntry(ENTRY_TYPE_PERSON, displayName, destination, destinationType,
+ destinationLabel, contactId, directoryId, dataId, (thumbnailUriAsString != null
+ ? Uri.parse(thumbnailUriAsString) : null), false, isValid, lookupKey);
+ }
+
+ @Override
+ public boolean isSamePerson(final RecipientEntry entry) {
+ return getDestination() != null && entry.getDestination() != null &&
+ TextUtils.equals(getDestination(), entry.getDestination());
+ }
+}
diff --git a/src/com/android/messaging/datamodel/ConversationImagePartsView.java b/src/com/android/messaging/datamodel/ConversationImagePartsView.java
new file mode 100644
index 0000000..70ba381
--- /dev/null
+++ b/src/com/android/messaging/datamodel/ConversationImagePartsView.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.provider.BaseColumns;
+
+import com.android.ex.photo.provider.PhotoContract.PhotoViewColumns;
+
+import com.android.messaging.datamodel.DatabaseHelper.MessageColumns;
+import com.android.messaging.datamodel.DatabaseHelper.PartColumns;
+import com.android.messaging.datamodel.DatabaseHelper.ParticipantColumns;
+import com.android.messaging.util.ContentType;
+
+/**
+ * View for the image parts for the conversation. It is used to provide the photoviewer with a
+ * a data source for all the photos in a conversation, so that the photoviewer can support paging
+ * through all the photos of the conversation. The columns of the view are a superset of
+ * {@link com.android.ex.photo.provider.PhotoContract.PhotoViewColumns}.
+ */
+public class ConversationImagePartsView {
+ private static final String VIEW_NAME = "conversation_image_parts_view";
+
+ private static final String CREATE_SQL = "CREATE VIEW " +
+ VIEW_NAME + " AS SELECT "
+ + DatabaseHelper.MESSAGES_TABLE + '.' + MessageColumns.CONVERSATION_ID
+ + " as " + Columns.CONVERSATION_ID + ", "
+ + DatabaseHelper.PARTS_TABLE + '.' + PartColumns.CONTENT_URI
+ + " as " + Columns.URI + ", "
+ + DatabaseHelper.PARTICIPANTS_TABLE + '.' + ParticipantColumns.FULL_NAME
+ + " as " + Columns.SENDER_FULL_NAME + ", "
+ + DatabaseHelper.PARTS_TABLE + '.' + PartColumns.CONTENT_URI
+ + " as " + Columns.CONTENT_URI + ", "
+ // Use NULL as the thumbnail uri
+ + " NULL as " + Columns.THUMBNAIL_URI + ", "
+ + DatabaseHelper.PARTS_TABLE + '.' + PartColumns.CONTENT_TYPE
+ + " as " + Columns.CONTENT_TYPE + ", "
+ //
+ // Columns in addition to those specified by PhotoContract
+ //
+ + DatabaseHelper.PARTICIPANTS_TABLE + '.' + ParticipantColumns.DISPLAY_DESTINATION
+ + " as " + Columns.DISPLAY_DESTINATION + ", "
+ + DatabaseHelper.MESSAGES_TABLE + '.' + MessageColumns.RECEIVED_TIMESTAMP
+ + " as " + Columns.RECEIVED_TIMESTAMP + ", "
+ + DatabaseHelper.MESSAGES_TABLE + '.' + MessageColumns.STATUS
+ + " as " + Columns.STATUS + " "
+
+ + " FROM " + DatabaseHelper.MESSAGES_TABLE + " LEFT JOIN " + DatabaseHelper.PARTS_TABLE
+ + " ON (" + DatabaseHelper.MESSAGES_TABLE + "." + MessageColumns._ID
+ + "=" + DatabaseHelper.PARTS_TABLE + "." + PartColumns.MESSAGE_ID + ") "
+ + " LEFT JOIN " + DatabaseHelper.PARTICIPANTS_TABLE + " ON ("
+ + DatabaseHelper.MESSAGES_TABLE + '.' + MessageColumns.SENDER_PARTICIPANT_ID
+ + '=' + DatabaseHelper.PARTICIPANTS_TABLE + '.' + ParticipantColumns._ID + ")"
+
+ // "content_type like 'image/%'"
+ + " WHERE " + DatabaseHelper.PARTS_TABLE + "." + PartColumns.CONTENT_TYPE
+ + " like '" + ContentType.IMAGE_PREFIX + "%'"
+
+ + " ORDER BY "
+ + DatabaseHelper.MESSAGES_TABLE + '.' + MessageColumns.RECEIVED_TIMESTAMP + " ASC, "
+ + DatabaseHelper.PARTS_TABLE + '.' + PartColumns._ID + " ASC";
+
+ static class Columns implements BaseColumns {
+ static final String CONVERSATION_ID = MessageColumns.CONVERSATION_ID;
+ static final String URI = PhotoViewColumns.URI;
+ static final String SENDER_FULL_NAME = PhotoViewColumns.NAME;
+ static final String CONTENT_URI = PhotoViewColumns.CONTENT_URI;
+ static final String THUMBNAIL_URI = PhotoViewColumns.THUMBNAIL_URI;
+ static final String CONTENT_TYPE = PhotoViewColumns.CONTENT_TYPE;
+ // Columns in addition to those specified by PhotoContract
+ static final String DISPLAY_DESTINATION = ParticipantColumns.DISPLAY_DESTINATION;
+ static final String RECEIVED_TIMESTAMP = MessageColumns.RECEIVED_TIMESTAMP;
+ static final String STATUS = MessageColumns.STATUS;
+ }
+
+ public interface PhotoViewQuery {
+ public final String[] PROJECTION = {
+ PhotoViewColumns.URI,
+ PhotoViewColumns.NAME,
+ PhotoViewColumns.CONTENT_URI,
+ PhotoViewColumns.THUMBNAIL_URI,
+ PhotoViewColumns.CONTENT_TYPE,
+ // Columns in addition to those specified by PhotoContract
+ Columns.DISPLAY_DESTINATION,
+ Columns.RECEIVED_TIMESTAMP,
+ Columns.STATUS,
+ };
+
+ public final int INDEX_URI = 0;
+ public final int INDEX_SENDER_FULL_NAME = 1;
+ public final int INDEX_CONTENT_URI = 2;
+ public final int INDEX_THUMBNAIL_URI = 3;
+ public final int INDEX_CONTENT_TYPE = 4;
+ // Columns in addition to those specified by PhotoContract
+ public final int INDEX_DISPLAY_DESTINATION = 5;
+ public final int INDEX_RECEIVED_TIMESTAMP = 6;
+ public final int INDEX_STATUS = 7;
+ }
+
+ static final String getViewName() {
+ return VIEW_NAME;
+ }
+
+ static final String getCreateSql() {
+ return CREATE_SQL;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/CursorQueryData.java b/src/com/android/messaging/datamodel/CursorQueryData.java
new file mode 100644
index 0000000..3e6a656
--- /dev/null
+++ b/src/com/android/messaging/datamodel/CursorQueryData.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+
+import com.android.messaging.util.Assert;
+import com.google.common.annotations.VisibleForTesting;
+
+/**
+ * Holds parameters and data (such as content URI) for performing queries on the content provider.
+ * This class could then be used to perform a query using either a BoundCursorLoader or querying
+ * on the content resolver directly.
+ *
+ * This class is used for cases where the way to load a cursor is not fixed. For example,
+ * when using ContactUtil to query for phone numbers, the ContactPickerFragment wants to use
+ * a CursorLoader to asynchronously load the data and tie in nicely with its data binding
+ * paradigm, whereas ContactRecipientAdapter wants to synchronously perform the query on the
+ * worker thread.
+ */
+public class CursorQueryData {
+ protected final Uri mUri;
+ protected final String[] mProjection;
+ protected final String mSelection;
+ protected final String[] mSelectionArgs;
+ protected final String mSortOrder;
+ protected final Context mContext;
+
+ public CursorQueryData(final Context context, final Uri uri, final String[] projection,
+ final String selection, final String[] selectionArgs, final String sortOrder) {
+ mContext = context;
+ mUri = uri;
+ mProjection = projection;
+ mSelection = selection;
+ mSelectionArgs = selectionArgs;
+ mSortOrder = sortOrder;
+ }
+
+ public BoundCursorLoader createBoundCursorLoader(final String bindingId) {
+ return new BoundCursorLoader(bindingId, mContext, mUri, mProjection, mSelection,
+ mSelectionArgs, mSortOrder);
+ }
+
+ public Cursor performSynchronousQuery() {
+ Assert.isNotMainThread();
+ if (mUri == null) {
+ // See {@link #getEmptyQueryData}
+ return null;
+ } else {
+ return mContext.getContentResolver().query(mUri, mProjection, mSelection,
+ mSelectionArgs, mSortOrder);
+ }
+ }
+
+ @VisibleForTesting
+ public Uri getUri() {
+ return mUri;
+ }
+
+ /**
+ * Representation of an invalid query. {@link #performSynchronousQuery} will return
+ * a null Cursor.
+ */
+ public static CursorQueryData getEmptyQueryData() {
+ return new CursorQueryData(null, null, null, null, null, null);
+ }
+}
diff --git a/src/com/android/messaging/datamodel/DataModel.java b/src/com/android/messaging/datamodel/DataModel.java
new file mode 100644
index 0000000..936b51c
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DataModel.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.android.messaging.Factory;
+import com.android.messaging.datamodel.action.Action;
+import com.android.messaging.datamodel.action.ActionService;
+import com.android.messaging.datamodel.action.BackgroundWorker;
+import com.android.messaging.datamodel.data.BlockedParticipantsData;
+import com.android.messaging.datamodel.data.BlockedParticipantsData.BlockedParticipantsDataListener;
+import com.android.messaging.datamodel.data.ContactListItemData;
+import com.android.messaging.datamodel.data.ContactPickerData;
+import com.android.messaging.datamodel.data.ContactPickerData.ContactPickerDataListener;
+import com.android.messaging.datamodel.data.ConversationData;
+import com.android.messaging.datamodel.data.ConversationData.ConversationDataListener;
+import com.android.messaging.datamodel.data.ConversationListData;
+import com.android.messaging.datamodel.data.ConversationListData.ConversationListDataListener;
+import com.android.messaging.datamodel.data.DraftMessageData;
+import com.android.messaging.datamodel.data.GalleryGridItemData;
+import com.android.messaging.datamodel.data.LaunchConversationData;
+import com.android.messaging.datamodel.data.LaunchConversationData.LaunchConversationDataListener;
+import com.android.messaging.datamodel.data.MediaPickerData;
+import com.android.messaging.datamodel.data.MessagePartData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.datamodel.data.ParticipantListItemData;
+import com.android.messaging.datamodel.data.PeopleAndOptionsData;
+import com.android.messaging.datamodel.data.PeopleAndOptionsData.PeopleAndOptionsDataListener;
+import com.android.messaging.datamodel.data.PeopleOptionsItemData;
+import com.android.messaging.datamodel.data.SettingsData;
+import com.android.messaging.datamodel.data.SettingsData.SettingsDataListener;
+import com.android.messaging.datamodel.data.SubscriptionListData;
+import com.android.messaging.datamodel.data.VCardContactItemData;
+import com.android.messaging.util.Assert.DoesNotRunOnMainThread;
+import com.android.messaging.util.ConnectivityUtil;
+
+public abstract class DataModel {
+ private String mFocusedConversation;
+ private boolean mConversationListScrolledToNewestConversation;
+
+ public static DataModel get() {
+ return Factory.get().getDataModel();
+ }
+
+ public static final void startActionService(final Action action) {
+ get().getActionService().startAction(action);
+ }
+
+ public static final void scheduleAction(final Action action,
+ final int code, final long delayMs) {
+ get().getActionService().scheduleAction(action, code, delayMs);
+ }
+
+ public abstract ConversationListData createConversationListData(final Context context,
+ final ConversationListDataListener listener, final boolean archivedMode);
+
+ public abstract ConversationData createConversationData(final Context context,
+ final ConversationDataListener listener, final String conversationId);
+
+ public abstract ContactListItemData createContactListItemData();
+
+ public abstract ContactPickerData createContactPickerData(final Context context,
+ final ContactPickerDataListener listener);
+
+ public abstract MediaPickerData createMediaPickerData(final Context context);
+
+ public abstract GalleryGridItemData createGalleryGridItemData();
+
+ public abstract LaunchConversationData createLaunchConversationData(
+ LaunchConversationDataListener listener);
+
+ public abstract PeopleOptionsItemData createPeopleOptionsItemData(final Context context);
+
+ public abstract PeopleAndOptionsData createPeopleAndOptionsData(final String conversationId,
+ final Context context, final PeopleAndOptionsDataListener listener);
+
+ public abstract VCardContactItemData createVCardContactItemData(final Context context,
+ final MessagePartData data);
+
+ public abstract VCardContactItemData createVCardContactItemData(final Context context,
+ final Uri vCardUri);
+
+ public abstract ParticipantListItemData createParticipantListItemData(
+ final ParticipantData participant);
+
+ public abstract BlockedParticipantsData createBlockedParticipantsData(Context context,
+ BlockedParticipantsDataListener listener);
+
+ public abstract SubscriptionListData createSubscriptonListData(Context context);
+
+ public abstract SettingsData createSettingsData(Context context, SettingsDataListener listener);
+
+ public abstract DraftMessageData createDraftMessageData(String conversationId);
+
+ public abstract ActionService getActionService();
+
+ public abstract BackgroundWorker getBackgroundWorkerForActionService();
+
+ @DoesNotRunOnMainThread
+ public abstract DatabaseWrapper getDatabase();
+
+ // Allow DataModel to coordinate with activity lifetime events.
+ public abstract void onActivityResume();
+
+ abstract void onCreateTables(final SQLiteDatabase db);
+
+ public void setFocusedConversation(final String conversationId) {
+ mFocusedConversation = conversationId;
+ }
+
+ public boolean isFocusedConversation(final String conversationId) {
+ return !TextUtils.isEmpty(mFocusedConversation)
+ && TextUtils.equals(mFocusedConversation, conversationId);
+ }
+
+ public void setConversationListScrolledToNewestConversation(
+ final boolean scrolledToNewestConversation) {
+ mConversationListScrolledToNewestConversation = scrolledToNewestConversation;
+ }
+
+ public boolean isConversationListScrolledToNewestConversation() {
+ return mConversationListScrolledToNewestConversation;
+ }
+
+ /**
+ * If a new message is received in the specified conversation, will the user be able to
+ * observe it in some UI within the app?
+ * @param conversationId conversation with the new incoming message
+ */
+ public boolean isNewMessageObservable(final String conversationId) {
+ return isConversationListScrolledToNewestConversation()
+ || isFocusedConversation(conversationId);
+ }
+
+ public abstract void onApplicationCreated();
+
+ public abstract ConnectivityUtil getConnectivityUtil();
+
+ public abstract SyncManager getSyncManager();
+}
diff --git a/src/com/android/messaging/datamodel/DataModelException.java b/src/com/android/messaging/datamodel/DataModelException.java
new file mode 100644
index 0000000..7084438
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DataModelException.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+public class DataModelException extends Exception {
+ private static final long serialVersionUID = 1L;
+
+ private static final int FIRST = 100;
+
+ // ERRORS GENERATED INTERNALLY BY DATA MODEL.
+
+ // ERRORS RELATED WITH SMS.
+ public static final int ERROR_SMS_TEMPORARY_FAILURE = 116;
+ public static final int ERROR_SMS_PERMANENT_FAILURE = 117;
+ public static final int ERROR_MMS_TEMPORARY_FAILURE = 118;
+ public static final int ERROR_MMS_PERMANENT_UNKNOWN_FAILURE = 119;
+
+ // Request expired.
+ public static final int ERROR_EXPIRED = 120;
+ // Request canceled by user.
+ public static final int ERROR_CANCELED = 121;
+
+ public static final int ERROR_MOBILE_DATA_DISABLED = 123;
+ public static final int ERROR_MMS_SERVICE_BLOCKED = 124;
+ public static final int ERROR_MMS_INVALID_ADDRESS = 125;
+ public static final int ERROR_MMS_NETWORK_PROBLEM = 126;
+ public static final int ERROR_MMS_MESSAGE_NOT_FOUND = 127;
+ public static final int ERROR_MMS_MESSAGE_FORMAT_CORRUPT = 128;
+ public static final int ERROR_MMS_CONTENT_NOT_ACCEPTED = 129;
+ public static final int ERROR_MMS_MESSAGE_NOT_SUPPORTED = 130;
+ public static final int ERROR_MMS_REPLY_CHARGING_ERROR = 131;
+ public static final int ERROR_MMS_ADDRESS_HIDING_NOT_SUPPORTED = 132;
+ public static final int ERROR_MMS_LACK_OF_PREPAID = 133;
+ public static final int ERROR_MMS_CAN_NOT_PERSIST = 134;
+ public static final int ERROR_MMS_NO_AVAILABLE_APN = 135;
+ public static final int ERROR_MMS_INVALID_MESSAGE_TO_SEND = 136;
+ public static final int ERROR_MMS_INVALID_MESSAGE_RECEIVED = 137;
+ public static final int ERROR_MMS_NO_CONFIGURATION = 138;
+
+ private static final int LAST = 138;
+
+ private final boolean mIsInjection;
+ private final int mErrorCode;
+ private final String mMessage;
+ private final long mBackoff;
+
+ public DataModelException(final int errorCode, final Exception innerException,
+ final long backoff, final boolean injection, final String message) {
+ // Since some of the exceptions passed in may not be serializable, only record message
+ // instead of setting inner exception for Exception class. Otherwise, we will get
+ // serialization issues when we pass ServerRequestException as intent extra later.
+ if (errorCode < FIRST || errorCode > LAST) {
+ throw new IllegalArgumentException("error code out of range: " + errorCode);
+ }
+ mIsInjection = injection;
+ mErrorCode = errorCode;
+ if (innerException != null) {
+ mMessage = innerException.getMessage() + " -- " +
+ (mIsInjection ? "[INJECTED] -- " : "") + message;
+ } else {
+ mMessage = (mIsInjection ? "[INJECTED] -- " : "") + message;
+ }
+
+ mBackoff = backoff;
+ }
+
+ public DataModelException(final int errorCode) {
+ this(errorCode, null, 0, false, null);
+ }
+
+ public DataModelException(final int errorCode, final Exception innerException) {
+ this(errorCode, innerException, 0, false, null);
+ }
+
+ public DataModelException(final int errorCode, final String message) {
+ this(errorCode, null, 0, false, message);
+ }
+
+ @Override
+ public String getMessage() {
+ return mMessage;
+ }
+
+ public int getErrorCode() {
+ return mErrorCode;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/DataModelImpl.java b/src/com/android/messaging/datamodel/DataModelImpl.java
new file mode 100644
index 0000000..6ab3f00
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DataModelImpl.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.telephony.SubscriptionManager;
+
+import com.android.messaging.datamodel.action.ActionService;
+import com.android.messaging.datamodel.action.BackgroundWorker;
+import com.android.messaging.datamodel.action.FixupMessageStatusOnStartupAction;
+import com.android.messaging.datamodel.action.ProcessPendingMessagesAction;
+import com.android.messaging.datamodel.data.BlockedParticipantsData;
+import com.android.messaging.datamodel.data.BlockedParticipantsData.BlockedParticipantsDataListener;
+import com.android.messaging.datamodel.data.ContactListItemData;
+import com.android.messaging.datamodel.data.ContactPickerData;
+import com.android.messaging.datamodel.data.ContactPickerData.ContactPickerDataListener;
+import com.android.messaging.datamodel.data.ConversationData;
+import com.android.messaging.datamodel.data.ConversationData.ConversationDataListener;
+import com.android.messaging.datamodel.data.ConversationListData;
+import com.android.messaging.datamodel.data.ConversationListData.ConversationListDataListener;
+import com.android.messaging.datamodel.data.DraftMessageData;
+import com.android.messaging.datamodel.data.GalleryGridItemData;
+import com.android.messaging.datamodel.data.LaunchConversationData;
+import com.android.messaging.datamodel.data.LaunchConversationData.LaunchConversationDataListener;
+import com.android.messaging.datamodel.data.MediaPickerData;
+import com.android.messaging.datamodel.data.MessagePartData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.datamodel.data.ParticipantListItemData;
+import com.android.messaging.datamodel.data.PeopleAndOptionsData;
+import com.android.messaging.datamodel.data.PeopleAndOptionsData.PeopleAndOptionsDataListener;
+import com.android.messaging.datamodel.data.PeopleOptionsItemData;
+import com.android.messaging.datamodel.data.SettingsData;
+import com.android.messaging.datamodel.data.SettingsData.SettingsDataListener;
+import com.android.messaging.datamodel.data.SubscriptionListData;
+import com.android.messaging.datamodel.data.VCardContactItemData;
+import com.android.messaging.sms.MmsConfig;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.Assert.DoesNotRunOnMainThread;
+import com.android.messaging.util.ConnectivityUtil;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.PhoneUtils;
+
+public class DataModelImpl extends DataModel {
+ private final Context mContext;
+ private final ActionService mActionService;
+ private final BackgroundWorker mDataModelWorker;
+ private final DatabaseHelper mDatabaseHelper;
+ private final ConnectivityUtil mConnectivityUtil;
+ private final SyncManager mSyncManager;
+
+ public DataModelImpl(final Context context) {
+ super();
+ mContext = context;
+ mActionService = new ActionService();
+ mDataModelWorker = new BackgroundWorker();
+ mDatabaseHelper = DatabaseHelper.getInstance(context);
+ mConnectivityUtil = new ConnectivityUtil(context);
+ mSyncManager = new SyncManager();
+ }
+
+ @Override
+ public ConversationListData createConversationListData(final Context context,
+ final ConversationListDataListener listener, final boolean archivedMode) {
+ return new ConversationListData(context, listener, archivedMode);
+ }
+
+ @Override
+ public ConversationData createConversationData(final Context context,
+ final ConversationDataListener listener, final String conversationId) {
+ return new ConversationData(context, listener, conversationId);
+ }
+
+ @Override
+ public ContactListItemData createContactListItemData() {
+ return new ContactListItemData();
+ }
+
+ @Override
+ public ContactPickerData createContactPickerData(final Context context,
+ final ContactPickerDataListener listener) {
+ return new ContactPickerData(context, listener);
+ }
+
+ @Override
+ public BlockedParticipantsData createBlockedParticipantsData(
+ final Context context, final BlockedParticipantsDataListener listener) {
+ return new BlockedParticipantsData(context, listener);
+ }
+
+ @Override
+ public MediaPickerData createMediaPickerData(final Context context) {
+ return new MediaPickerData(context);
+ }
+
+ @Override
+ public GalleryGridItemData createGalleryGridItemData() {
+ return new GalleryGridItemData();
+ }
+
+ @Override
+ public LaunchConversationData createLaunchConversationData(
+ final LaunchConversationDataListener listener) {
+ return new LaunchConversationData(listener);
+ }
+
+ @Override
+ public PeopleOptionsItemData createPeopleOptionsItemData(final Context context) {
+ return new PeopleOptionsItemData(context);
+ }
+
+ @Override
+ public PeopleAndOptionsData createPeopleAndOptionsData(final String conversationId,
+ final Context context, final PeopleAndOptionsDataListener listener) {
+ return new PeopleAndOptionsData(conversationId, context, listener);
+ }
+
+ @Override
+ public VCardContactItemData createVCardContactItemData(final Context context,
+ final MessagePartData data) {
+ return new VCardContactItemData(context, data);
+ }
+
+ @Override
+ public VCardContactItemData createVCardContactItemData(final Context context,
+ final Uri vCardUri) {
+ return new VCardContactItemData(context, vCardUri);
+ }
+
+ @Override
+ public ParticipantListItemData createParticipantListItemData(
+ final ParticipantData participant) {
+ return new ParticipantListItemData(participant);
+ }
+
+ @Override
+ public SubscriptionListData createSubscriptonListData(Context context) {
+ return new SubscriptionListData(context);
+ }
+
+ @Override
+ public SettingsData createSettingsData(Context context, SettingsDataListener listener) {
+ return new SettingsData(context, listener);
+ }
+
+ @Override
+ public DraftMessageData createDraftMessageData(String conversationId) {
+ return new DraftMessageData(conversationId);
+ }
+
+ @Override
+ public ActionService getActionService() {
+ // We need to allow access to this on the UI thread since it's used to start actions.
+ return mActionService;
+ }
+
+ @Override
+ public BackgroundWorker getBackgroundWorkerForActionService() {
+ return mDataModelWorker;
+ }
+
+ @Override
+ @DoesNotRunOnMainThread
+ public DatabaseWrapper getDatabase() {
+ // We prevent the main UI thread from accessing the database since we have to allow
+ // public access to this class to enable sub-packages to access data.
+ Assert.isNotMainThread();
+ return mDatabaseHelper.getDatabase();
+ }
+
+ @Override
+ public ConnectivityUtil getConnectivityUtil() {
+ return mConnectivityUtil;
+ }
+
+ @Override
+ public SyncManager getSyncManager() {
+ return mSyncManager;
+ }
+
+ @Override
+ void onCreateTables(final SQLiteDatabase db) {
+ LogUtil.w(LogUtil.BUGLE_TAG, "Rebuilt databases: reseting related state");
+ // Clear other things that implicitly reference the DB
+ SyncManager.resetLastSyncTimestamps();
+ }
+
+ @Override
+ public void onActivityResume() {
+ // Perform an incremental sync and register for changes if necessary
+ mSyncManager.updateSyncObserver(mContext);
+
+ // Trigger a participant refresh if needed, we should only need to refresh if there is
+ // contact change while the activity was paused.
+ ParticipantRefresh.refreshParticipantsIfNeeded();
+ }
+
+ @Override
+ public void onApplicationCreated() {
+ FixupMessageStatusOnStartupAction.fixupMessageStatus();
+ ProcessPendingMessagesAction.processFirstPendingMessage();
+ SyncManager.immediateSync();
+
+ if (OsUtil.isAtLeastL_MR1()) {
+ // Start listening for subscription change events for refreshing self participants.
+ PhoneUtils.getDefault().toLMr1().registerOnSubscriptionsChangedListener(
+ new SubscriptionManager.OnSubscriptionsChangedListener() {
+ @Override
+ public void onSubscriptionsChanged() {
+ // TODO: This dynamically changes the mms config that app is
+ // currently using. It may cause inconsistency in some cases. We need
+ // to check the usage of mms config and handle the dynamic change
+ // gracefully
+ MmsConfig.loadAsync();
+ ParticipantRefresh.refreshSelfParticipants();
+ }
+ });
+ }
+ }
+}
diff --git a/src/com/android/messaging/datamodel/DatabaseHelper.java b/src/com/android/messaging/datamodel/DatabaseHelper.java
new file mode 100644
index 0000000..f16bb3c
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DatabaseHelper.java
@@ -0,0 +1,813 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.provider.BaseColumns;
+
+import com.android.messaging.BugleApplication;
+import com.android.messaging.R;
+import com.android.messaging.datamodel.data.ConversationListItemData;
+import com.android.messaging.datamodel.data.MessageData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.Assert.DoesNotRunOnMainThread;
+import com.android.messaging.util.LogUtil;
+import com.google.common.annotations.VisibleForTesting;
+
+/**
+ * TODO: Open Issues:
+ * - Should we be storing the draft messages in the regular messages table or should we have a
+ * separate table for drafts to keep the normal messages query as simple as possible?
+ */
+
+/**
+ * Allows access to the SQL database. This is package private.
+ */
+public class DatabaseHelper extends SQLiteOpenHelper {
+ public static final String DATABASE_NAME = "bugle_db";
+
+ private static final int getDatabaseVersion(final Context context) {
+ return Integer.parseInt(context.getResources().getString(R.string.database_version));
+ }
+
+ /** Table containing names of all other tables and views */
+ private static final String MASTER_TABLE = "sqlite_master";
+ /** Column containing the name of the tables and views */
+ private static final String[] MASTER_COLUMNS = new String[] { "name", };
+
+ // Table names
+ public static final String CONVERSATIONS_TABLE = "conversations";
+ public static final String MESSAGES_TABLE = "messages";
+ public static final String PARTS_TABLE = "parts";
+ public static final String PARTICIPANTS_TABLE = "participants";
+ public static final String CONVERSATION_PARTICIPANTS_TABLE = "conversation_participants";
+
+ // Views
+ static final String DRAFT_PARTS_VIEW = "draft_parts_view";
+
+ // Conversations table schema
+ public static class ConversationColumns implements BaseColumns {
+ /* SMS/MMS Thread ID from the system provider */
+ public static final String SMS_THREAD_ID = "sms_thread_id";
+
+ /* Display name for the conversation */
+ public static final String NAME = "name";
+
+ /* Latest Message ID for the read status to display in conversation list */
+ public static final String LATEST_MESSAGE_ID = "latest_message_id";
+
+ /* Latest text snippet for display in conversation list */
+ public static final String SNIPPET_TEXT = "snippet_text";
+
+ /* Latest text subject for display in conversation list, empty string if none exists */
+ public static final String SUBJECT_TEXT = "subject_text";
+
+ /* Preview Uri */
+ public static final String PREVIEW_URI = "preview_uri";
+
+ /* The preview uri's content type */
+ public static final String PREVIEW_CONTENT_TYPE = "preview_content_type";
+
+ /* If we should display the current draft snippet/preview pair or snippet/preview pair */
+ public static final String SHOW_DRAFT = "show_draft";
+
+ /* Latest draft text subject for display in conversation list, empty string if none exists*/
+ public static final String DRAFT_SUBJECT_TEXT = "draft_subject_text";
+
+ /* Latest draft text snippet for display, empty string if none exists */
+ public static final String DRAFT_SNIPPET_TEXT = "draft_snippet_text";
+
+ /* Draft Preview Uri, empty string if none exists */
+ public static final String DRAFT_PREVIEW_URI = "draft_preview_uri";
+
+ /* The preview uri's content type */
+ public static final String DRAFT_PREVIEW_CONTENT_TYPE = "draft_preview_content_type";
+
+ /* If this conversation is archived */
+ public static final String ARCHIVE_STATUS = "archive_status";
+
+ /* Timestamp for sorting purposes */
+ public static final String SORT_TIMESTAMP = "sort_timestamp";
+
+ /* Last read message timestamp */
+ public static final String LAST_READ_TIMESTAMP = "last_read_timestamp";
+
+ /* Avatar for the conversation. Could be for group of individual */
+ public static final String ICON = "icon";
+
+ /* Participant contact ID if this conversation has a single participant. -1 otherwise */
+ public static final String PARTICIPANT_CONTACT_ID = "participant_contact_id";
+
+ /* Participant lookup key if this conversation has a single participant. null otherwise */
+ public static final String PARTICIPANT_LOOKUP_KEY = "participant_lookup_key";
+
+ /*
+ * Participant's normalized destination if this conversation has a single participant.
+ * null otherwise.
+ */
+ public static final String OTHER_PARTICIPANT_NORMALIZED_DESTINATION =
+ "participant_normalized_destination";
+
+ /* Default self participant for the conversation */
+ public static final String CURRENT_SELF_ID = "current_self_id";
+
+ /* Participant count not including self (so will be 1 for 1:1 or bigger for group) */
+ public static final String PARTICIPANT_COUNT = "participant_count";
+
+ /* Should notifications be enabled for this conversation? */
+ public static final String NOTIFICATION_ENABLED = "notification_enabled";
+
+ /* Notification sound used for the conversation */
+ public static final String NOTIFICATION_SOUND_URI = "notification_sound_uri";
+
+ /* Should vibrations be enabled for the conversation's notification? */
+ public static final String NOTIFICATION_VIBRATION = "notification_vibration";
+
+ /* Conversation recipients include email address */
+ public static final String INCLUDE_EMAIL_ADDRESS = "include_email_addr";
+
+ // Record the last received sms's service center info if it indicates that the reply path
+ // is present (TP-Reply-Path), so that we could use it for the subsequent message to send.
+ // Refer to TS 23.040 D.6 and SmsMessageSender.java in Android Messaging app.
+ public static final String SMS_SERVICE_CENTER = "sms_service_center";
+ }
+
+ // Conversation table SQL
+ private static final String CREATE_CONVERSATIONS_TABLE_SQL =
+ "CREATE TABLE " + CONVERSATIONS_TABLE + "("
+ + ConversationColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ // TODO : Int? Required not default?
+ + ConversationColumns.SMS_THREAD_ID + " INT DEFAULT(0), "
+ + ConversationColumns.NAME + " TEXT, "
+ + ConversationColumns.LATEST_MESSAGE_ID + " INT, "
+ + ConversationColumns.SNIPPET_TEXT + " TEXT, "
+ + ConversationColumns.SUBJECT_TEXT + " TEXT, "
+ + ConversationColumns.PREVIEW_URI + " TEXT, "
+ + ConversationColumns.PREVIEW_CONTENT_TYPE + " TEXT, "
+ + ConversationColumns.SHOW_DRAFT + " INT DEFAULT(0), "
+ + ConversationColumns.DRAFT_SNIPPET_TEXT + " TEXT, "
+ + ConversationColumns.DRAFT_SUBJECT_TEXT + " TEXT, "
+ + ConversationColumns.DRAFT_PREVIEW_URI + " TEXT, "
+ + ConversationColumns.DRAFT_PREVIEW_CONTENT_TYPE + " TEXT, "
+ + ConversationColumns.ARCHIVE_STATUS + " INT DEFAULT(0), "
+ + ConversationColumns.SORT_TIMESTAMP + " INT DEFAULT(0), "
+ + ConversationColumns.LAST_READ_TIMESTAMP + " INT DEFAULT(0), "
+ + ConversationColumns.ICON + " TEXT, "
+ + ConversationColumns.PARTICIPANT_CONTACT_ID + " INT DEFAULT ( "
+ + ParticipantData.PARTICIPANT_CONTACT_ID_NOT_RESOLVED + "), "
+ + ConversationColumns.PARTICIPANT_LOOKUP_KEY + " TEXT, "
+ + ConversationColumns.OTHER_PARTICIPANT_NORMALIZED_DESTINATION + " TEXT, "
+ + ConversationColumns.CURRENT_SELF_ID + " TEXT, "
+ + ConversationColumns.PARTICIPANT_COUNT + " INT DEFAULT(0), "
+ + ConversationColumns.NOTIFICATION_ENABLED + " INT DEFAULT(1), "
+ + ConversationColumns.NOTIFICATION_SOUND_URI + " TEXT, "
+ + ConversationColumns.NOTIFICATION_VIBRATION + " INT DEFAULT(1), "
+ + ConversationColumns.INCLUDE_EMAIL_ADDRESS + " INT DEFAULT(0), "
+ + ConversationColumns.SMS_SERVICE_CENTER + " TEXT "
+ + ");";
+
+ private static final String CONVERSATIONS_TABLE_SMS_THREAD_ID_INDEX_SQL =
+ "CREATE INDEX index_" + CONVERSATIONS_TABLE + "_" + ConversationColumns.SMS_THREAD_ID
+ + " ON " + CONVERSATIONS_TABLE
+ + "(" + ConversationColumns.SMS_THREAD_ID + ")";
+
+ private static final String CONVERSATIONS_TABLE_ARCHIVE_STATUS_INDEX_SQL =
+ "CREATE INDEX index_" + CONVERSATIONS_TABLE + "_" + ConversationColumns.ARCHIVE_STATUS
+ + " ON " + CONVERSATIONS_TABLE
+ + "(" + ConversationColumns.ARCHIVE_STATUS + ")";
+
+ private static final String CONVERSATIONS_TABLE_SORT_TIMESTAMP_INDEX_SQL =
+ "CREATE INDEX index_" + CONVERSATIONS_TABLE + "_" + ConversationColumns.SORT_TIMESTAMP
+ + " ON " + CONVERSATIONS_TABLE
+ + "(" + ConversationColumns.SORT_TIMESTAMP + ")";
+
+ // Messages table schema
+ public static class MessageColumns implements BaseColumns {
+ /* conversation id that this message belongs to */
+ public static final String CONVERSATION_ID = "conversation_id";
+
+ /* participant which send this message */
+ public static final String SENDER_PARTICIPANT_ID = "sender_id";
+
+ /* This is bugle's internal status for the message */
+ public static final String STATUS = "message_status";
+
+ /* Type of message: SMS, MMS or MMS notification */
+ public static final String PROTOCOL = "message_protocol";
+
+ /* This is the time that the sender sent the message */
+ public static final String SENT_TIMESTAMP = "sent_timestamp";
+
+ /* Time that we received the message on this device */
+ public static final String RECEIVED_TIMESTAMP = "received_timestamp";
+
+ /* When the message has been seen by a user in a notification */
+ public static final String SEEN = "seen";
+
+ /* When the message has been read by a user */
+ public static final String READ = "read";
+
+ /* participant representing the sim which processed this message */
+ public static final String SELF_PARTICIPANT_ID = "self_id";
+
+ /*
+ * Time when a retry is initiated. This is used to compute the retry window
+ * when we retry sending/downloading a message.
+ */
+ public static final String RETRY_START_TIMESTAMP = "retry_start_timestamp";
+
+ // Columns which map to the SMS provider
+
+ /* Message ID from the platform provider */
+ public static final String SMS_MESSAGE_URI = "sms_message_uri";
+
+ /* The message priority for MMS message */
+ public static final String SMS_PRIORITY = "sms_priority";
+
+ /* The message size for MMS message */
+ public static final String SMS_MESSAGE_SIZE = "sms_message_size";
+
+ /* The subject for MMS message */
+ public static final String MMS_SUBJECT = "mms_subject";
+
+ /* Transaction id for MMS notificaiton */
+ public static final String MMS_TRANSACTION_ID = "mms_transaction_id";
+
+ /* Content location for MMS notificaiton */
+ public static final String MMS_CONTENT_LOCATION = "mms_content_location";
+
+ /* The expiry time (ms) for MMS message */
+ public static final String MMS_EXPIRY = "mms_expiry";
+
+ /* The detailed status (RESPONSE_STATUS or RETRIEVE_STATUS) for MMS message */
+ public static final String RAW_TELEPHONY_STATUS = "raw_status";
+ }
+
+ // Messages table SQL
+ private static final String CREATE_MESSAGES_TABLE_SQL =
+ "CREATE TABLE " + MESSAGES_TABLE + " ("
+ + MessageColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
+ + MessageColumns.CONVERSATION_ID + " INT, "
+ + MessageColumns.SENDER_PARTICIPANT_ID + " INT, "
+ + MessageColumns.SENT_TIMESTAMP + " INT DEFAULT(0), "
+ + MessageColumns.RECEIVED_TIMESTAMP + " INT DEFAULT(0), "
+ + MessageColumns.PROTOCOL + " INT DEFAULT(0), "
+ + MessageColumns.STATUS + " INT DEFAULT(0), "
+ + MessageColumns.SEEN + " INT DEFAULT(0), "
+ + MessageColumns.READ + " INT DEFAULT(0), "
+ + MessageColumns.SMS_MESSAGE_URI + " TEXT, "
+ + MessageColumns.SMS_PRIORITY + " INT DEFAULT(0), "
+ + MessageColumns.SMS_MESSAGE_SIZE + " INT DEFAULT(0), "
+ + MessageColumns.MMS_SUBJECT + " TEXT, "
+ + MessageColumns.MMS_TRANSACTION_ID + " TEXT, "
+ + MessageColumns.MMS_CONTENT_LOCATION + " TEXT, "
+ + MessageColumns.MMS_EXPIRY + " INT DEFAULT(0), "
+ + MessageColumns.RAW_TELEPHONY_STATUS + " INT DEFAULT(0), "
+ + MessageColumns.SELF_PARTICIPANT_ID + " INT, "
+ + MessageColumns.RETRY_START_TIMESTAMP + " INT DEFAULT(0), "
+ + "FOREIGN KEY (" + MessageColumns.CONVERSATION_ID + ") REFERENCES "
+ + CONVERSATIONS_TABLE + "(" + ConversationColumns._ID + ") ON DELETE CASCADE "
+ + "FOREIGN KEY (" + MessageColumns.SENDER_PARTICIPANT_ID + ") REFERENCES "
+ + PARTICIPANTS_TABLE + "(" + ParticipantColumns._ID + ") ON DELETE SET NULL "
+ + "FOREIGN KEY (" + MessageColumns.SELF_PARTICIPANT_ID + ") REFERENCES "
+ + PARTICIPANTS_TABLE + "(" + ParticipantColumns._ID + ") ON DELETE SET NULL "
+ + ");";
+
+ // Primary sort index for messages table : by conversation id, status, received timestamp.
+ private static final String MESSAGES_TABLE_SORT_INDEX_SQL =
+ "CREATE INDEX index_" + MESSAGES_TABLE + "_sort ON " + MESSAGES_TABLE + "("
+ + MessageColumns.CONVERSATION_ID + ", "
+ + MessageColumns.STATUS + ", "
+ + MessageColumns.RECEIVED_TIMESTAMP + ")";
+
+ private static final String MESSAGES_TABLE_STATUS_SEEN_INDEX_SQL =
+ "CREATE INDEX index_" + MESSAGES_TABLE + "_status_seen ON " + MESSAGES_TABLE + "("
+ + MessageColumns.STATUS + ", "
+ + MessageColumns.SEEN + ")";
+
+ // Parts table schema
+ // A part may contain text or a media url, but not both.
+ public static class PartColumns implements BaseColumns {
+ /* message id that this part belongs to */
+ public static final String MESSAGE_ID = "message_id";
+
+ /* conversation id that this part belongs to */
+ public static final String CONVERSATION_ID = "conversation_id";
+
+ /* text for this part */
+ public static final String TEXT = "text";
+
+ /* content uri for this part */
+ public static final String CONTENT_URI = "uri";
+
+ /* content type for this part */
+ public static final String CONTENT_TYPE = "content_type";
+
+ /* cached width for this part (for layout while loading) */
+ public static final String WIDTH = "width";
+
+ /* cached height for this part (for layout while loading) */
+ public static final String HEIGHT = "height";
+
+ /* de-normalized copy of timestamp from the messages table. This is populated
+ * via an insert trigger on the parts table.
+ */
+ public static final String TIMESTAMP = "timestamp";
+ }
+
+ // Message part table SQL
+ private static final String CREATE_PARTS_TABLE_SQL =
+ "CREATE TABLE " + PARTS_TABLE + "("
+ + PartColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
+ + PartColumns.MESSAGE_ID + " INT,"
+ + PartColumns.TEXT + " TEXT,"
+ + PartColumns.CONTENT_URI + " TEXT,"
+ + PartColumns.CONTENT_TYPE + " TEXT,"
+ + PartColumns.WIDTH + " INT DEFAULT("
+ + MessagingContentProvider.UNSPECIFIED_SIZE + "),"
+ + PartColumns.HEIGHT + " INT DEFAULT("
+ + MessagingContentProvider.UNSPECIFIED_SIZE + "),"
+ + PartColumns.TIMESTAMP + " INT, "
+ + PartColumns.CONVERSATION_ID + " INT NOT NULL,"
+ + "FOREIGN KEY (" + PartColumns.MESSAGE_ID + ") REFERENCES "
+ + MESSAGES_TABLE + "(" + MessageColumns._ID + ") ON DELETE CASCADE "
+ + "FOREIGN KEY (" + PartColumns.CONVERSATION_ID + ") REFERENCES "
+ + CONVERSATIONS_TABLE + "(" + ConversationColumns._ID + ") ON DELETE CASCADE "
+ + ");";
+
+ public static final String CREATE_PARTS_TRIGGER_SQL =
+ "CREATE TRIGGER " + PARTS_TABLE + "_TRIGGER" + " AFTER INSERT ON " + PARTS_TABLE
+ + " FOR EACH ROW "
+ + " BEGIN UPDATE " + PARTS_TABLE
+ + " SET " + PartColumns.TIMESTAMP + "="
+ + " (SELECT received_timestamp FROM " + MESSAGES_TABLE + " WHERE " + MESSAGES_TABLE
+ + "." + MessageColumns._ID + "=" + "NEW." + PartColumns.MESSAGE_ID + ")"
+ + " WHERE " + PARTS_TABLE + "." + PartColumns._ID + "=" + "NEW." + PartColumns._ID
+ + "; END";
+
+ public static final String CREATE_MESSAGES_TRIGGER_SQL =
+ "CREATE TRIGGER " + MESSAGES_TABLE + "_TRIGGER" + " AFTER UPDATE OF "
+ + MessageColumns.RECEIVED_TIMESTAMP + " ON " + MESSAGES_TABLE
+ + " FOR EACH ROW BEGIN UPDATE " + PARTS_TABLE + " SET " + PartColumns.TIMESTAMP
+ + " = NEW." + MessageColumns.RECEIVED_TIMESTAMP + " WHERE " + PARTS_TABLE + "."
+ + PartColumns.MESSAGE_ID + " = NEW." + MessageColumns._ID
+ + "; END;";
+
+ // Primary sort index for parts table : by message_id
+ private static final String PARTS_TABLE_MESSAGE_INDEX_SQL =
+ "CREATE INDEX index_" + PARTS_TABLE + "_message_id ON " + PARTS_TABLE + "("
+ + PartColumns.MESSAGE_ID + ")";
+
+ // Participants table schema
+ public static class ParticipantColumns implements BaseColumns {
+ /* The subscription id for the sim associated with this self participant.
+ * Introduced in L. For earlier versions will always be default_sub_id (-1).
+ * For multi sim devices (or cases where the sim was changed) single device
+ * may have several different sub_id values */
+ public static final String SUB_ID = "sub_id";
+
+ /* The slot of the active SIM (inserted in the device) for this self-participant. If the
+ * self-participant doesn't correspond to any active SIM, this will be
+ * {@link android.telephony.SubscriptionManager#INVALID_SLOT_ID}.
+ * The column is ignored for all non-self participants.
+ */
+ public static final String SIM_SLOT_ID = "sim_slot_id";
+
+ /* The phone number stored in a standard E164 format if possible. This is unique for a
+ * given participant. We can't handle multiple participants with the same phone number
+ * since we don't know which of them a message comes from. This can also be an email
+ * address, in which case this is the same as the displayed address */
+ public static final String NORMALIZED_DESTINATION = "normalized_destination";
+
+ /* The phone number as originally supplied and used for dialing. Not necessarily in E164
+ * format or unique */
+ public static final String SEND_DESTINATION = "send_destination";
+
+ /* The user-friendly formatting of the phone number according to the region setting of
+ * the device when the row was added. */
+ public static final String DISPLAY_DESTINATION = "display_destination";
+
+ /* A string with this participant's full name or a pretty printed phone number */
+ public static final String FULL_NAME = "full_name";
+
+ /* A string with just this participant's first name */
+ public static final String FIRST_NAME = "first_name";
+
+ /* A local URI to an asset for the icon for this participant */
+ public static final String PROFILE_PHOTO_URI = "profile_photo_uri";
+
+ /* Contact id for matching local contact for this participant */
+ public static final String CONTACT_ID = "contact_id";
+
+ /* String that contains hints on how to find contact information in a contact lookup */
+ public static final String LOOKUP_KEY = "lookup_key";
+
+ /* If this participant is blocked */
+ public static final String BLOCKED = "blocked";
+
+ /* The color of the subscription (FOR SELF PARTICIPANTS ONLY) */
+ public static final String SUBSCRIPTION_COLOR = "subscription_color";
+
+ /* The name of the subscription (FOR SELF PARTICIPANTS ONLY) */
+ public static final String SUBSCRIPTION_NAME = "subscription_name";
+
+ /* The exact destination stored in Contacts for this participant */
+ public static final String CONTACT_DESTINATION = "contact_destination";
+ }
+
+ // Participants table SQL
+ private static final String CREATE_PARTICIPANTS_TABLE_SQL =
+ "CREATE TABLE " + PARTICIPANTS_TABLE + "("
+ + ParticipantColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
+ + ParticipantColumns.SUB_ID + " INT DEFAULT("
+ + ParticipantData.OTHER_THAN_SELF_SUB_ID + "),"
+ + ParticipantColumns.SIM_SLOT_ID + " INT DEFAULT("
+ + ParticipantData.INVALID_SLOT_ID + "),"
+ + ParticipantColumns.NORMALIZED_DESTINATION + " TEXT,"
+ + ParticipantColumns.SEND_DESTINATION + " TEXT,"
+ + ParticipantColumns.DISPLAY_DESTINATION + " TEXT,"
+ + ParticipantColumns.FULL_NAME + " TEXT,"
+ + ParticipantColumns.FIRST_NAME + " TEXT,"
+ + ParticipantColumns.PROFILE_PHOTO_URI + " TEXT, "
+ + ParticipantColumns.CONTACT_ID + " INT DEFAULT( "
+ + ParticipantData.PARTICIPANT_CONTACT_ID_NOT_RESOLVED + "), "
+ + ParticipantColumns.LOOKUP_KEY + " STRING, "
+ + ParticipantColumns.BLOCKED + " INT DEFAULT(0), "
+ + ParticipantColumns.SUBSCRIPTION_NAME + " TEXT, "
+ + ParticipantColumns.SUBSCRIPTION_COLOR + " INT DEFAULT(0), "
+ + ParticipantColumns.CONTACT_DESTINATION + " TEXT, "
+ + "UNIQUE (" + ParticipantColumns.NORMALIZED_DESTINATION + ", "
+ + ParticipantColumns.SUB_ID + ") ON CONFLICT FAIL" + ");";
+
+ private static final String CREATE_SELF_PARTICIPANT_SQL =
+ "INSERT INTO " + PARTICIPANTS_TABLE
+ + " ( " + ParticipantColumns.SUB_ID + " ) VALUES ( %s )";
+
+ static String getCreateSelfParticipantSql(int subId) {
+ return String.format(CREATE_SELF_PARTICIPANT_SQL, subId);
+ }
+
+ // Conversation Participants table schema - contains a list of participants excluding the user
+ // in a given conversation.
+ public static class ConversationParticipantsColumns implements BaseColumns {
+ /* participant id of someone in this conversation */
+ public static final String PARTICIPANT_ID = "participant_id";
+
+ /* conversation id that this participant belongs to */
+ public static final String CONVERSATION_ID = "conversation_id";
+ }
+
+ // Conversation Participants table SQL
+ private static final String CREATE_CONVERSATION_PARTICIPANTS_TABLE_SQL =
+ "CREATE TABLE " + CONVERSATION_PARTICIPANTS_TABLE + "("
+ + ConversationParticipantsColumns._ID + " INTEGER PRIMARY KEY AUTOINCREMENT,"
+ + ConversationParticipantsColumns.CONVERSATION_ID + " INT,"
+ + ConversationParticipantsColumns.PARTICIPANT_ID + " INT,"
+ + "UNIQUE (" + ConversationParticipantsColumns.CONVERSATION_ID + ","
+ + ConversationParticipantsColumns.PARTICIPANT_ID + ") ON CONFLICT FAIL, "
+ + "FOREIGN KEY (" + ConversationParticipantsColumns.CONVERSATION_ID + ") "
+ + "REFERENCES " + CONVERSATIONS_TABLE + "(" + ConversationColumns._ID + ")"
+ + " ON DELETE CASCADE "
+ + "FOREIGN KEY (" + ConversationParticipantsColumns.PARTICIPANT_ID + ")"
+ + " REFERENCES " + PARTICIPANTS_TABLE + "(" + ParticipantColumns._ID + "));";
+
+ // Primary access pattern for conversation participants is to look them up for a specific
+ // conversation.
+ private static final String CONVERSATION_PARTICIPANTS_TABLE_CONVERSATION_ID_INDEX_SQL =
+ "CREATE INDEX index_" + CONVERSATION_PARTICIPANTS_TABLE + "_"
+ + ConversationParticipantsColumns.CONVERSATION_ID
+ + " ON " + CONVERSATION_PARTICIPANTS_TABLE
+ + "(" + ConversationParticipantsColumns.CONVERSATION_ID + ")";
+
+ // View for getting parts which are for draft messages.
+ static final String DRAFT_PARTS_VIEW_SQL = "CREATE VIEW " +
+ DRAFT_PARTS_VIEW + " AS SELECT "
+ + PARTS_TABLE + '.' + PartColumns._ID
+ + " as " + PartColumns._ID + ", "
+ + PARTS_TABLE + '.' + PartColumns.MESSAGE_ID
+ + " as " + PartColumns.MESSAGE_ID + ", "
+ + PARTS_TABLE + '.' + PartColumns.TEXT
+ + " as " + PartColumns.TEXT + ", "
+ + PARTS_TABLE + '.' + PartColumns.CONTENT_URI
+ + " as " + PartColumns.CONTENT_URI + ", "
+ + PARTS_TABLE + '.' + PartColumns.CONTENT_TYPE
+ + " as " + PartColumns.CONTENT_TYPE + ", "
+ + PARTS_TABLE + '.' + PartColumns.WIDTH
+ + " as " + PartColumns.WIDTH + ", "
+ + PARTS_TABLE + '.' + PartColumns.HEIGHT
+ + " as " + PartColumns.HEIGHT + ", "
+ + MESSAGES_TABLE + '.' + MessageColumns.CONVERSATION_ID
+ + " as " + MessageColumns.CONVERSATION_ID + " "
+ + " FROM " + MESSAGES_TABLE + " LEFT JOIN " + PARTS_TABLE + " ON ("
+ + MESSAGES_TABLE + "." + MessageColumns._ID
+ + "=" + PARTS_TABLE + "." + PartColumns.MESSAGE_ID + ")"
+ // Exclude draft messages from main view
+ + " WHERE " + MESSAGES_TABLE + "." + MessageColumns.STATUS
+ + " = " + MessageData.BUGLE_STATUS_OUTGOING_DRAFT;
+
+ // List of all our SQL tables
+ private static final String[] CREATE_TABLE_SQLS = new String[] {
+ CREATE_CONVERSATIONS_TABLE_SQL,
+ CREATE_MESSAGES_TABLE_SQL,
+ CREATE_PARTS_TABLE_SQL,
+ CREATE_PARTICIPANTS_TABLE_SQL,
+ CREATE_CONVERSATION_PARTICIPANTS_TABLE_SQL,
+ };
+
+ // List of all our indices
+ private static final String[] CREATE_INDEX_SQLS = new String[] {
+ CONVERSATIONS_TABLE_SMS_THREAD_ID_INDEX_SQL,
+ CONVERSATIONS_TABLE_ARCHIVE_STATUS_INDEX_SQL,
+ CONVERSATIONS_TABLE_SORT_TIMESTAMP_INDEX_SQL,
+ MESSAGES_TABLE_SORT_INDEX_SQL,
+ MESSAGES_TABLE_STATUS_SEEN_INDEX_SQL,
+ PARTS_TABLE_MESSAGE_INDEX_SQL,
+ CONVERSATION_PARTICIPANTS_TABLE_CONVERSATION_ID_INDEX_SQL,
+ };
+
+ // List of all our SQL triggers
+ private static final String[] CREATE_TRIGGER_SQLS = new String[] {
+ CREATE_PARTS_TRIGGER_SQL,
+ CREATE_MESSAGES_TRIGGER_SQL,
+ };
+
+ // List of all our views
+ private static final String[] CREATE_VIEW_SQLS = new String[] {
+ ConversationListItemData.getConversationListViewSql(),
+ ConversationImagePartsView.getCreateSql(),
+ DRAFT_PARTS_VIEW_SQL,
+ };
+
+ private static final Object sLock = new Object();
+ private final Context mApplicationContext;
+ private static DatabaseHelper sHelperInstance; // Protected by sLock.
+
+ private final Object mDatabaseWrapperLock = new Object();
+ private DatabaseWrapper mDatabaseWrapper; // Protected by mDatabaseWrapperLock.
+ private final DatabaseUpgradeHelper mUpgradeHelper = new DatabaseUpgradeHelper();
+
+ /**
+ * Get a (singleton) instance of {@link DatabaseHelper}, creating one if there isn't one yet.
+ * This is the only public method for getting a new instance of the class.
+ * @param context Should be the application context (or something that will live for the
+ * lifetime of the application).
+ * @return The current (or a new) DatabaseHelper instance.
+ */
+ public static DatabaseHelper getInstance(final Context context) {
+ synchronized (sLock) {
+ if (sHelperInstance == null) {
+ sHelperInstance = new DatabaseHelper(context);
+ }
+ return sHelperInstance;
+ }
+ }
+
+ /**
+ * Private constructor, used from {@link #getInstance()}.
+ * @param context Should be the application context (or something that will live for the
+ * lifetime of the application).
+ */
+ private DatabaseHelper(final Context context) {
+ super(context, DATABASE_NAME, null, getDatabaseVersion(context), null);
+ mApplicationContext = context;
+ }
+
+ /**
+ * Test method that always instantiates a new DatabaseHelper instance. This should
+ * be used ONLY by the tests and never by the real application.
+ * @param context Test context.
+ * @return Brand new DatabaseHelper instance.
+ */
+ @VisibleForTesting
+ static DatabaseHelper getNewInstanceForTest(final Context context) {
+ Assert.isEngBuild();
+ Assert.isTrue(BugleApplication.isRunningTests());
+ return new DatabaseHelper(context);
+ }
+
+ /**
+ * Get the (singleton) instance of @{link DatabaseWrapper}.
+ * The database is always opened as a writeable database.
+ * @return The current (or a new) DatabaseWrapper instance.
+ */
+ @DoesNotRunOnMainThread
+ DatabaseWrapper getDatabase() {
+ // We prevent the main UI thread from accessing the database here since we have to allow
+ // public access to this class to enable sub-packages to access data.
+ Assert.isNotMainThread();
+
+ synchronized (mDatabaseWrapperLock) {
+ if (mDatabaseWrapper == null) {
+ mDatabaseWrapper = new DatabaseWrapper(mApplicationContext, getWritableDatabase());
+ }
+ return mDatabaseWrapper;
+ }
+ }
+
+ @Override
+ public void onDowngrade(final SQLiteDatabase db, final int oldVersion, final int newVersion) {
+ mUpgradeHelper.onDowngrade(db, oldVersion, newVersion);
+ }
+
+ /**
+ * Drops and recreates all tables.
+ */
+ public static void rebuildTables(final SQLiteDatabase db) {
+ // Drop tables first, then views, and indices.
+ dropAllTables(db);
+ dropAllViews(db);
+ dropAllIndexes(db);
+ dropAllTriggers(db);
+
+ // Recreate the whole database.
+ createDatabase(db);
+ }
+
+ /**
+ * Drop and rebuild a given view.
+ */
+ static void rebuildView(final SQLiteDatabase db, final String viewName,
+ final String createViewSql) {
+ dropView(db, viewName, true /* throwOnFailure */);
+ db.execSQL(createViewSql);
+ }
+
+ private static void dropView(final SQLiteDatabase db, final String viewName,
+ final boolean throwOnFailure) {
+ final String dropPrefix = "DROP VIEW IF EXISTS ";
+ try {
+ db.execSQL(dropPrefix + viewName);
+ } catch (final SQLException ex) {
+ if (LogUtil.isLoggable(LogUtil.BUGLE_TAG, LogUtil.DEBUG)) {
+ LogUtil.d(LogUtil.BUGLE_TAG, "unable to drop view " + viewName + " "
+ + ex);
+ }
+
+ if (throwOnFailure) {
+ throw ex;
+ }
+ }
+ }
+
+ /**
+ * Drops all user-defined tables from the given database.
+ */
+ private static void dropAllTables(final SQLiteDatabase db) {
+ final Cursor tableCursor =
+ db.query(MASTER_TABLE, MASTER_COLUMNS, "type='table'", null, null, null, null);
+ if (tableCursor != null) {
+ try {
+ final String dropPrefix = "DROP TABLE IF EXISTS ";
+ while (tableCursor.moveToNext()) {
+ final String tableName = tableCursor.getString(0);
+
+ // Skip special tables
+ if (tableName.startsWith("android_") || tableName.startsWith("sqlite_")) {
+ continue;
+ }
+ try {
+ db.execSQL(dropPrefix + tableName);
+ } catch (final SQLException ex) {
+ if (LogUtil.isLoggable(LogUtil.BUGLE_TAG, LogUtil.DEBUG)) {
+ LogUtil.d(LogUtil.BUGLE_TAG, "unable to drop table " + tableName + " "
+ + ex);
+ }
+ }
+ }
+ } finally {
+ tableCursor.close();
+ }
+ }
+ }
+
+ /**
+ * Drops all user-defined triggers from the given database.
+ */
+ private static void dropAllTriggers(final SQLiteDatabase db) {
+ final Cursor triggerCursor =
+ db.query(MASTER_TABLE, MASTER_COLUMNS, "type='trigger'", null, null, null, null);
+ if (triggerCursor != null) {
+ try {
+ final String dropPrefix = "DROP TRIGGER IF EXISTS ";
+ while (triggerCursor.moveToNext()) {
+ final String triggerName = triggerCursor.getString(0);
+
+ // Skip special tables
+ if (triggerName.startsWith("android_") || triggerName.startsWith("sqlite_")) {
+ continue;
+ }
+ try {
+ db.execSQL(dropPrefix + triggerName);
+ } catch (final SQLException ex) {
+ if (LogUtil.isLoggable(LogUtil.BUGLE_TAG, LogUtil.DEBUG)) {
+ LogUtil.d(LogUtil.BUGLE_TAG, "unable to drop trigger " + triggerName +
+ " " + ex);
+ }
+ }
+ }
+ } finally {
+ triggerCursor.close();
+ }
+ }
+ }
+
+ /**
+ * Drops all user-defined views from the given database.
+ */
+ private static void dropAllViews(final SQLiteDatabase db) {
+ final Cursor viewCursor =
+ db.query(MASTER_TABLE, MASTER_COLUMNS, "type='view'", null, null, null, null);
+ if (viewCursor != null) {
+ try {
+ while (viewCursor.moveToNext()) {
+ final String viewName = viewCursor.getString(0);
+ dropView(db, viewName, false /* throwOnFailure */);
+ }
+ } finally {
+ viewCursor.close();
+ }
+ }
+ }
+
+ /**
+ * Drops all user-defined views from the given database.
+ */
+ private static void dropAllIndexes(final SQLiteDatabase db) {
+ final Cursor indexCursor =
+ db.query(MASTER_TABLE, MASTER_COLUMNS, "type='index'", null, null, null, null);
+ if (indexCursor != null) {
+ try {
+ final String dropPrefix = "DROP INDEX IF EXISTS ";
+ while (indexCursor.moveToNext()) {
+ final String indexName = indexCursor.getString(0);
+ try {
+ db.execSQL(dropPrefix + indexName);
+ } catch (final SQLException ex) {
+ if (LogUtil.isLoggable(LogUtil.BUGLE_TAG, LogUtil.DEBUG)) {
+ LogUtil.d(LogUtil.BUGLE_TAG, "unable to drop index " + indexName + " "
+ + ex);
+ }
+ }
+ }
+ } finally {
+ indexCursor.close();
+ }
+ }
+ }
+
+ private static void createDatabase(final SQLiteDatabase db) {
+ for (final String sql : CREATE_TABLE_SQLS) {
+ db.execSQL(sql);
+ }
+
+ for (final String sql : CREATE_INDEX_SQLS) {
+ db.execSQL(sql);
+ }
+
+ for (final String sql : CREATE_VIEW_SQLS) {
+ db.execSQL(sql);
+ }
+
+ for (final String sql : CREATE_TRIGGER_SQLS) {
+ db.execSQL(sql);
+ }
+
+ // Enable foreign key constraints
+ db.execSQL("PRAGMA foreign_keys=ON;");
+
+ // Add the default self participant. The default self will be assigned a proper slot id
+ // during participant refresh.
+ db.execSQL(getCreateSelfParticipantSql(ParticipantData.DEFAULT_SELF_SUB_ID));
+
+ DataModel.get().onCreateTables(db);
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ createDatabase(db);
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ mUpgradeHelper.doOnUpgrade(db, oldVersion, newVersion);
+ }
+}
diff --git a/src/com/android/messaging/datamodel/DatabaseUpgradeHelper.java b/src/com/android/messaging/datamodel/DatabaseUpgradeHelper.java
new file mode 100644
index 0000000..d112533
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DatabaseUpgradeHelper.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.database.sqlite.SQLiteDatabase;
+
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.LogUtil;
+
+public class DatabaseUpgradeHelper {
+ private static final String TAG = LogUtil.BUGLE_DATABASE_TAG;
+
+ public void doOnUpgrade(final SQLiteDatabase db, final int oldVersion, final int newVersion) {
+ Assert.isTrue(newVersion >= oldVersion);
+ if (oldVersion == newVersion) {
+ return;
+ }
+
+ LogUtil.i(TAG, "Database upgrade started from version " + oldVersion + " to " + newVersion);
+
+ // Add future upgrade code here
+ }
+
+ public void onDowngrade(final SQLiteDatabase db, final int oldVersion, final int newVersion) {
+ DatabaseHelper.rebuildTables(db);
+ LogUtil.e(TAG, "Database downgrade requested for version " +
+ oldVersion + " version " + newVersion + ", forcing db rebuild!");
+ }
+}
diff --git a/src/com/android/messaging/datamodel/DatabaseWrapper.java b/src/com/android/messaging/datamodel/DatabaseWrapper.java
new file mode 100644
index 0000000..ca7a331
--- /dev/null
+++ b/src/com/android/messaging/datamodel/DatabaseWrapper.java
@@ -0,0 +1,482 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteFullException;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.database.sqlite.SQLiteStatement;
+import android.util.SparseArray;
+
+import com.android.messaging.Factory;
+import com.android.messaging.R;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.BugleGservicesKeys;
+import com.android.messaging.util.DebugUtils;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.UiUtils;
+
+import java.util.Locale;
+import java.util.Stack;
+import java.util.regex.Pattern;
+
+public class DatabaseWrapper {
+ private static final String TAG = LogUtil.BUGLE_DATABASE_TAG;
+
+ private final SQLiteDatabase mDatabase;
+ private final Context mContext;
+ private final boolean mLog;
+ /**
+ * Set mExplainQueryPlanRegexp (via {@link BugleGservicesKeys#EXPLAIN_QUERY_PLAN_REGEXP}
+ * to regex matching queries to see query plans. For example, ".*" to show all query plans.
+ */
+ // See
+ private final String mExplainQueryPlanRegexp;
+ private static final int sTimingThreshold = 50; // in milliseconds
+
+ public static final int INDEX_INSERT_MESSAGE_PART = 0;
+ public static final int INDEX_INSERT_MESSAGE = 1;
+ public static final int INDEX_QUERY_CONVERSATIONS_LATEST_MESSAGE = 2;
+ public static final int INDEX_QUERY_MESSAGES_LATEST_MESSAGE = 3;
+
+ private final SparseArray mCompiledStatements;
+
+ static class TransactionData {
+ long time;
+ boolean transactionSuccessful;
+ }
+
+ // track transaction on a per thread basis
+ private static ThreadLocal> sTransactionDepth =
+ new ThreadLocal>() {
+ @Override
+ public Stack initialValue() {
+ return new Stack();
+ }
+ };
+
+ private static String[] sFormatStrings = new String[] {
+ "took %d ms to %s",
+ " took %d ms to %s",
+ " took %d ms to %s",
+ };
+
+ DatabaseWrapper(final Context context, final SQLiteDatabase db) {
+ mLog = LogUtil.isLoggable(LogUtil.BUGLE_DATABASE_PERF_TAG, LogUtil.VERBOSE);
+ mExplainQueryPlanRegexp = Factory.get().getBugleGservices().getString(
+ BugleGservicesKeys.EXPLAIN_QUERY_PLAN_REGEXP, null);
+ mDatabase = db;
+ mContext = context;
+ mCompiledStatements = new SparseArray();
+ }
+
+ public SQLiteStatement getStatementInTransaction(final int index, final String statement) {
+ // Use transaction to serialize access to statements
+ Assert.isTrue(mDatabase.inTransaction());
+ SQLiteStatement compiled = mCompiledStatements.get(index);
+ if (compiled == null) {
+ compiled = mDatabase.compileStatement(statement);
+ Assert.isTrue(compiled.toString().contains(statement.trim()));
+ mCompiledStatements.put(index, compiled);
+ }
+ return compiled;
+ }
+
+ private void maybePlayDebugNoise() {
+ DebugUtils.maybePlayDebugNoise(mContext, DebugUtils.DEBUG_SOUND_DB_OP);
+ }
+
+ private static void printTiming(final long t1, final String msg) {
+ final int transactionDepth = sTransactionDepth.get().size();
+ final long t2 = System.currentTimeMillis();
+ final long delta = t2 - t1;
+ if (delta > sTimingThreshold) {
+ LogUtil.v(LogUtil.BUGLE_DATABASE_PERF_TAG, String.format(Locale.US,
+ sFormatStrings[Math.min(sFormatStrings.length - 1, transactionDepth)],
+ delta,
+ msg));
+ }
+ }
+
+ public Context getContext() {
+ return mContext;
+ }
+
+ public void beginTransaction() {
+ final long t1 = System.currentTimeMillis();
+
+ // push the current time onto the transaction stack
+ final TransactionData f = new TransactionData();
+ f.time = t1;
+ sTransactionDepth.get().push(f);
+
+ mDatabase.beginTransaction();
+ }
+
+ public void setTransactionSuccessful() {
+ final TransactionData f = sTransactionDepth.get().peek();
+ f.transactionSuccessful = true;
+ mDatabase.setTransactionSuccessful();
+ }
+
+ public void endTransaction() {
+ long t1 = 0;
+ long transactionStartTime = 0;
+ final TransactionData f = sTransactionDepth.get().pop();
+ if (f.transactionSuccessful == false) {
+ LogUtil.w(TAG, "endTransaction without setting successful");
+ for (final StackTraceElement st : (new Exception()).getStackTrace()) {
+ LogUtil.w(TAG, " " + st.toString());
+ }
+ }
+ if (mLog) {
+ transactionStartTime = f.time;
+ t1 = System.currentTimeMillis();
+ }
+ try {
+ mDatabase.endTransaction();
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to endTransaction", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US,
+ ">>> endTransaction (total for this transaction: %d)",
+ (System.currentTimeMillis() - transactionStartTime)));
+ }
+ }
+
+ public void yieldTransaction() {
+ long yieldStartTime = 0;
+ if (mLog) {
+ yieldStartTime = System.currentTimeMillis();
+ }
+ final boolean wasYielded = mDatabase.yieldIfContendedSafely();
+ if (wasYielded && mLog) {
+ printTiming(yieldStartTime, "yieldTransaction");
+ }
+ }
+
+ public void insertWithOnConflict(final String searchTable, final String nullColumnHack,
+ final ContentValues initialValues, final int conflictAlgorithm) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ try {
+ mDatabase.insertWithOnConflict(searchTable, nullColumnHack, initialValues,
+ conflictAlgorithm);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to insertWithOnConflict", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US,
+ "insertWithOnConflict with ", searchTable));
+ }
+ }
+
+ private void explainQueryPlan(final SQLiteQueryBuilder qb, final SQLiteDatabase db,
+ final String[] projection, final String selection,
+ @SuppressWarnings("unused")
+ final String[] queryArgs,
+ final String groupBy,
+ @SuppressWarnings("unused")
+ final String having,
+ final String sortOrder, final String limit) {
+ final String queryString = qb.buildQuery(
+ projection,
+ selection,
+ groupBy,
+ null/*having*/,
+ sortOrder,
+ limit);
+ explainQueryPlan(db, queryString, queryArgs);
+ }
+
+ private void explainQueryPlan(final SQLiteDatabase db, final String sql,
+ final String[] queryArgs) {
+ if (!Pattern.matches(mExplainQueryPlanRegexp, sql)) {
+ return;
+ }
+ final Cursor planCursor = db.rawQuery("explain query plan " + sql, queryArgs);
+ try {
+ if (planCursor != null && planCursor.moveToFirst()) {
+ final int detailColumn = planCursor.getColumnIndex("detail");
+ final StringBuilder sb = new StringBuilder();
+ do {
+ sb.append(planCursor.getString(detailColumn));
+ sb.append("\n");
+ } while (planCursor.moveToNext());
+ if (sb.length() > 0) {
+ sb.setLength(sb.length() - 1);
+ }
+ LogUtil.v(TAG, "for query " + sql + "\nplan is: "
+ + sb.toString());
+ }
+ } catch (final Exception e) {
+ LogUtil.w(TAG, "Query plan failed ", e);
+ } finally {
+ if (planCursor != null) {
+ planCursor.close();
+ }
+ }
+ }
+
+ public Cursor query(final String searchTable, final String[] projection,
+ final String selection, final String[] selectionArgs, final String groupBy,
+ final String having, final String orderBy, final String limit) {
+ if (mExplainQueryPlanRegexp != null) {
+ final SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+ qb.setTables(searchTable);
+ explainQueryPlan(qb, mDatabase, projection, selection, selectionArgs,
+ groupBy, having, orderBy, limit);
+ }
+
+ maybePlayDebugNoise();
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ final Cursor cursor = mDatabase.query(searchTable, projection, selection, selectionArgs,
+ groupBy, having, orderBy, limit);
+ if (mLog) {
+ printTiming(
+ t1,
+ String.format(Locale.US, "query %s with %s ==> %d",
+ searchTable, selection, cursor.getCount()));
+ }
+ return cursor;
+ }
+
+ public Cursor query(final String searchTable, final String[] columns,
+ final String selection, final String[] selectionArgs, final String groupBy,
+ final String having, final String orderBy) {
+ return query(
+ searchTable, columns, selection, selectionArgs,
+ groupBy, having, orderBy, null);
+ }
+
+ public Cursor query(final SQLiteQueryBuilder qb,
+ final String[] projection, final String selection, final String[] queryArgs,
+ final String groupBy, final String having, final String sortOrder, final String limit) {
+ if (mExplainQueryPlanRegexp != null) {
+ explainQueryPlan(qb, mDatabase, projection, selection, queryArgs,
+ groupBy, having, sortOrder, limit);
+ }
+ maybePlayDebugNoise();
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ final Cursor cursor = qb.query(mDatabase, projection, selection, queryArgs, groupBy,
+ having, sortOrder, limit);
+ if (mLog) {
+ printTiming(
+ t1,
+ String.format(Locale.US, "query %s with %s ==> %d",
+ qb.getTables(), selection, cursor.getCount()));
+ }
+ return cursor;
+ }
+
+ public long queryNumEntries(final String table, final String selection,
+ final String[] selectionArgs) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ final long retval =
+ DatabaseUtils.queryNumEntries(mDatabase, table, selection, selectionArgs);
+ if (mLog){
+ printTiming(
+ t1,
+ String.format(Locale.US, "queryNumEntries %s with %s ==> %d", table,
+ selection, retval));
+ }
+ return retval;
+ }
+
+ public Cursor rawQuery(final String sql, final String[] args) {
+ if (mExplainQueryPlanRegexp != null) {
+ explainQueryPlan(mDatabase, sql, args);
+ }
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ final Cursor cursor = mDatabase.rawQuery(sql, args);
+ if (mLog) {
+ printTiming(
+ t1,
+ String.format(Locale.US, "rawQuery %s ==> %d", sql, cursor.getCount()));
+ }
+ return cursor;
+ }
+
+ public int update(final String table, final ContentValues values,
+ final String selection, final String[] selectionArgs) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ int count = 0;
+ try {
+ count = mDatabase.update(table, values, selection, selectionArgs);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to update", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "update %s with %s ==> %d",
+ table, selection, count));
+ }
+ return count;
+ }
+
+ public int delete(final String table, final String whereClause, final String[] whereArgs) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ int count = 0;
+ try {
+ count = mDatabase.delete(table, whereClause, whereArgs);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to delete", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1,
+ String.format(Locale.US, "delete from %s with %s ==> %d", table,
+ whereClause, count));
+ }
+ return count;
+ }
+
+ public long insert(final String table, final String nullColumnHack,
+ final ContentValues values) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ long rowId = -1;
+ try {
+ rowId = mDatabase.insert(table, nullColumnHack, values);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to insert", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "insert to %s", table));
+ }
+ return rowId;
+ }
+
+ public long replace(final String table, final String nullColumnHack,
+ final ContentValues values) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ long rowId = -1;
+ try {
+ rowId = mDatabase.replace(table, nullColumnHack, values);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to replace", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "replace to %s", table));
+ }
+ return rowId;
+ }
+
+ public void setLocale(final Locale locale) {
+ mDatabase.setLocale(locale);
+ }
+
+ public void execSQL(final String sql, final String[] bindArgs) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ try {
+ mDatabase.execSQL(sql, bindArgs);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to execSQL", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "execSQL %s", sql));
+ }
+ }
+
+ public void execSQL(final String sql) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ try {
+ mDatabase.execSQL(sql);
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to execSQL", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "execSQL %s", sql));
+ }
+ }
+
+ public int execSQLUpdateDelete(final String sql) {
+ long t1 = 0;
+ if (mLog) {
+ t1 = System.currentTimeMillis();
+ }
+ maybePlayDebugNoise();
+ final SQLiteStatement statement = mDatabase.compileStatement(sql);
+ int rowsUpdated = 0;
+ try {
+ rowsUpdated = statement.executeUpdateDelete();
+ } catch (SQLiteFullException ex) {
+ LogUtil.e(TAG, "Database full, unable to execSQLUpdateDelete", ex);
+ UiUtils.showToastAtBottom(R.string.db_full);
+ }
+ if (mLog) {
+ printTiming(t1, String.format(Locale.US, "execSQLUpdateDelete %s", sql));
+ }
+ return rowsUpdated;
+ }
+
+ public SQLiteDatabase getDatabase() {
+ return mDatabase;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/FileProvider.java b/src/com/android/messaging/datamodel/FileProvider.java
new file mode 100644
index 0000000..ee332cd
--- /dev/null
+++ b/src/com/android/messaging/datamodel/FileProvider.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Random;
+
+/**
+ * A very simple content provider that can serve files.
+ */
+public abstract class FileProvider extends ContentProvider {
+ // Object to generate random id for temp images.
+ private static final Random RANDOM_ID = new Random();
+
+ abstract File getFile(final String path, final String extension);
+
+ private static final String FILE_EXTENSION_PARAM_KEY = "ext";
+
+ /**
+ * Check if filename conforms to requirement for our provider
+ * @param fileId filename (optionally starting with path character
+ * @return true if filename consists only of digits
+ */
+ protected static boolean isValidFileId(final String fileId) {
+ // Ignore initial "/"
+ for (int index = (fileId.startsWith("/") ? 1 : 0); index < fileId.length(); index++) {
+ final Character c = fileId.charAt(index);
+ if (!Character.isDigit(c)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Create a temp file (to allow writing to that one particular file)
+ * @param file the file to create
+ * @return true if file successfully created
+ */
+ protected static boolean ensureFileExists(final File file) {
+ try {
+ final File parentDir = file.getParentFile();
+ if (parentDir.exists() || parentDir.mkdirs()) {
+ return file.createNewFile();
+ }
+ } catch (final IOException e) {
+ // fail on exceptions creating the file
+ }
+ return false;
+ }
+
+ /**
+ * Build uri for a new temporary file (creating file)
+ * @param authority authority with which to populate uri
+ * @param extension optional file extension
+ * @return unique uri that can be used to write temporary files
+ */
+ protected static Uri buildFileUri(final String authority, final String extension) {
+ final long fileId = Math.abs(RANDOM_ID.nextLong());
+ final Uri.Builder builder = (new Uri.Builder()).authority(authority).scheme(
+ ContentResolver.SCHEME_CONTENT);
+ builder.appendPath(String.valueOf(fileId));
+ if (!TextUtils.isEmpty(extension)) {
+ builder.appendQueryParameter(FILE_EXTENSION_PARAM_KEY, extension);
+ }
+ return builder.build();
+ }
+
+ @Override
+ public boolean onCreate() {
+ return true;
+ }
+
+ @Override
+ public int delete(final Uri uri, final String selection, final String[] selectionArgs) {
+ final String fileId = uri.getPath();
+ if (isValidFileId(fileId)) {
+ final File file = getFile(fileId, getExtensionFromUri(uri));
+ return file.delete() ? 1 : 0;
+ }
+ return 0;
+ }
+
+ @Override
+ public ParcelFileDescriptor openFile(final Uri uri, final String fileMode)
+ throws FileNotFoundException {
+ final String fileId = uri.getPath();
+ if (isValidFileId(fileId)) {
+ final File file = getFile(fileId, getExtensionFromUri(uri));
+ final int mode =
+ (TextUtils.equals(fileMode, "r") ? ParcelFileDescriptor.MODE_READ_ONLY :
+ ParcelFileDescriptor.MODE_WRITE_ONLY | ParcelFileDescriptor.MODE_TRUNCATE);
+ return ParcelFileDescriptor.open(file, mode);
+ }
+ return null;
+ }
+
+ protected static String getExtensionFromUri(final Uri uri) {
+ return uri.getQueryParameter(FILE_EXTENSION_PARAM_KEY);
+ }
+
+ @Override
+ public Cursor query(final Uri uri, final String[] projection, final String selection,
+ final String[] selectionArgs, final String sortOrder) {
+ // Don't support queries.
+ return null;
+ }
+
+ @Override
+ public Uri insert(final Uri uri, final ContentValues values) {
+ // Don't support inserts.
+ return null;
+ }
+
+ @Override
+ public int update(final Uri uri, final ContentValues values, final String selection,
+ final String[] selectionArgs) {
+ // Don't support updates.
+ return 0;
+ }
+
+ @Override
+ public String getType(final Uri uri) {
+ // No need for mime types.
+ return null;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java b/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java
new file mode 100644
index 0000000..62483a0
--- /dev/null
+++ b/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.support.v4.util.SimpleArrayMap;
+
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.ContactUtil;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+/**
+ * A cursor builder that takes the frequent contacts cursor and aggregate it with the all contacts
+ * cursor to fill in contact details such as phone numbers and strip away invalid contacts.
+ *
+ * Because the frequent contact list depends on the loading of two cursors, it needs to temporarily
+ * store the cursor that it receives with setFrequents() and setAllContacts() calls. Because it
+ * doesn't know which one will be finished first, it always checks whether both cursors are ready
+ * to pull data from and construct the aggregate cursor when it's ready to do so. Note that
+ * this cursor builder doesn't assume ownership of the cursors passed in - it merely references
+ * them and always does a isClosed() check before consuming them. The ownership still belongs to
+ * the loader framework and the cursor may be closed when the UI is torn down.
+ */
+public class FrequentContactsCursorBuilder {
+ private Cursor mAllContactsCursor;
+ private Cursor mFrequentContactsCursor;
+
+ /**
+ * Sets the frequent contacts cursor as soon as it is loaded, or null if it's reset.
+ * @return this builder instance for chained operations
+ */
+ public FrequentContactsCursorBuilder setFrequents(final Cursor frequentContactsCursor) {
+ mFrequentContactsCursor = frequentContactsCursor;
+ return this;
+ }
+
+ /**
+ * Sets the all contacts cursor as soon as it is loaded, or null if it's reset.
+ * @return this builder instance for chained operations
+ */
+ public FrequentContactsCursorBuilder setAllContacts(final Cursor allContactsCursor) {
+ mAllContactsCursor = allContactsCursor;
+ return this;
+ }
+
+ /**
+ * Reset this builder. Must be called when the consumer resets its data.
+ */
+ public void resetBuilder() {
+ mAllContactsCursor = null;
+ mFrequentContactsCursor = null;
+ }
+
+ /**
+ * Attempt to build the cursor records from the frequent and all contacts cursor if they
+ * are both ready to be consumed.
+ * @return the frequent contact cursor if built successfully, or null if it can't be built yet.
+ */
+ public Cursor build() {
+ if (mFrequentContactsCursor != null && mAllContactsCursor != null) {
+ Assert.isTrue(!mFrequentContactsCursor.isClosed());
+ Assert.isTrue(!mAllContactsCursor.isClosed());
+
+ // Frequent contacts cursor has one record per contact, plus it doesn't contain info
+ // such as phone number and type. In order for the records to be usable by Bugle, we
+ // would like to populate it with information from the all contacts cursor.
+ final MatrixCursor retCursor = new MatrixCursor(ContactUtil.PhoneQuery.PROJECTION);
+
+ // First, go through the frequents cursor and take note of all lookup keys and their
+ // corresponding rank in the frequents list.
+ final SimpleArrayMap lookupKeyToRankMap =
+ new SimpleArrayMap();
+ int oldPosition = mFrequentContactsCursor.getPosition();
+ int rank = 0;
+ mFrequentContactsCursor.moveToPosition(-1);
+ while (mFrequentContactsCursor.moveToNext()) {
+ final String lookupKey = mFrequentContactsCursor.getString(
+ ContactUtil.INDEX_LOOKUP_KEY_FREQUENT);
+ lookupKeyToRankMap.put(lookupKey, rank++);
+ }
+ mFrequentContactsCursor.moveToPosition(oldPosition);
+
+ // Second, go through the all contacts cursor once and retrieve all information
+ // (multiple phone numbers etc.) and store that in an array list. Since the all
+ // contacts list only contains phone contacts, this step will ensure that we filter
+ // out any invalid/email contacts in the frequents list.
+ final ArrayList rows =
+ new ArrayList(mFrequentContactsCursor.getCount());
+ oldPosition = mAllContactsCursor.getPosition();
+ mAllContactsCursor.moveToPosition(-1);
+ while (mAllContactsCursor.moveToNext()) {
+ final String lookupKey = mAllContactsCursor.getString(ContactUtil.INDEX_LOOKUP_KEY);
+ if (lookupKeyToRankMap.containsKey(lookupKey)) {
+ final Object[] row = new Object[ContactUtil.PhoneQuery.PROJECTION.length];
+ row[ContactUtil.INDEX_DATA_ID] =
+ mAllContactsCursor.getLong(ContactUtil.INDEX_DATA_ID);
+ row[ContactUtil.INDEX_CONTACT_ID] =
+ mAllContactsCursor.getLong(ContactUtil.INDEX_CONTACT_ID);
+ row[ContactUtil.INDEX_LOOKUP_KEY] =
+ mAllContactsCursor.getString(ContactUtil.INDEX_LOOKUP_KEY);
+ row[ContactUtil.INDEX_DISPLAY_NAME] =
+ mAllContactsCursor.getString(ContactUtil.INDEX_DISPLAY_NAME);
+ row[ContactUtil.INDEX_PHOTO_URI] =
+ mAllContactsCursor.getString(ContactUtil.INDEX_PHOTO_URI);
+ row[ContactUtil.INDEX_PHONE_EMAIL] =
+ mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL);
+ row[ContactUtil.INDEX_PHONE_EMAIL_TYPE] =
+ mAllContactsCursor.getInt(ContactUtil.INDEX_PHONE_EMAIL_TYPE);
+ row[ContactUtil.INDEX_PHONE_EMAIL_LABEL] =
+ mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL_LABEL);
+ rows.add(row);
+ }
+ }
+ mAllContactsCursor.moveToPosition(oldPosition);
+
+ // Now we have a list of rows containing frequent contacts in alphabetical order.
+ // Therefore, sort all the rows according to their actual ranks in the frequents list.
+ Collections.sort(rows, new Comparator() {
+ @Override
+ public int compare(final Object[] lhs, final Object[] rhs) {
+ final String lookupKeyLhs = (String) lhs[ContactUtil.INDEX_LOOKUP_KEY];
+ final String lookupKeyRhs = (String) rhs[ContactUtil.INDEX_LOOKUP_KEY];
+ Assert.isTrue(lookupKeyToRankMap.containsKey(lookupKeyLhs) &&
+ lookupKeyToRankMap.containsKey(lookupKeyRhs));
+ final int rankLhs = lookupKeyToRankMap.get(lookupKeyLhs);
+ final int rankRhs = lookupKeyToRankMap.get(lookupKeyRhs);
+ if (rankLhs < rankRhs) {
+ return -1;
+ } else if (rankLhs > rankRhs) {
+ return 1;
+ } else {
+ // Same rank, so it's two contact records for the same contact.
+ // Perform secondary sorting on the phone type. Always place
+ // mobile before everything else.
+ final int phoneTypeLhs = (int) lhs[ContactUtil.INDEX_PHONE_EMAIL_TYPE];
+ final int phoneTypeRhs = (int) rhs[ContactUtil.INDEX_PHONE_EMAIL_TYPE];
+ if (phoneTypeLhs == Phone.TYPE_MOBILE &&
+ phoneTypeRhs == Phone.TYPE_MOBILE) {
+ return 0;
+ } else if (phoneTypeLhs == Phone.TYPE_MOBILE) {
+ return -1;
+ } else if (phoneTypeRhs == Phone.TYPE_MOBILE) {
+ return 1;
+ } else {
+ // Use the default sort order, i.e. sort by phoneType value.
+ return phoneTypeLhs < phoneTypeRhs ? -1 :
+ (phoneTypeLhs == phoneTypeRhs ? 0 : 1);
+ }
+ }
+ }
+ });
+
+ // Finally, add all the rows to this cursor.
+ for (final Object[] row : rows) {
+ retCursor.addRow(row);
+ }
+ return retCursor;
+ }
+ return null;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/FrequentContactsCursorQueryData.java b/src/com/android/messaging/datamodel/FrequentContactsCursorQueryData.java
new file mode 100644
index 0000000..d1759ad
--- /dev/null
+++ b/src/com/android/messaging/datamodel/FrequentContactsCursorQueryData.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+
+import com.android.messaging.util.FallbackStrategies;
+import com.android.messaging.util.FallbackStrategies.Strategy;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+
+/**
+ * Helper for querying frequent (and/or starred) contacts.
+ */
+public class FrequentContactsCursorQueryData extends CursorQueryData {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ private static class FrequentContactsCursorLoader extends BoundCursorLoader {
+ private final Uri mOriginalUri;
+
+ FrequentContactsCursorLoader(String bindingId, Context context, Uri uri,
+ String[] projection, String selection, String[] selectionArgs, String sortOrder) {
+ super(bindingId, context, uri, projection, selection, selectionArgs, sortOrder);
+ mOriginalUri = uri;
+ }
+
+ @Override
+ public Cursor loadInBackground() {
+ return FallbackStrategies
+ .startWith(new PrimaryStrequentContactsQueryStrategy())
+ .thenTry(new FrequentOnlyContactsQueryStrategy())
+ .thenTry(new PhoneOnlyStrequentContactsQueryStrategy())
+ .execute(null);
+ }
+
+ private abstract class StrequentContactsQueryStrategy implements Strategy {
+ @Override
+ public Cursor execute(Void params) throws Exception {
+ final Uri uri = getUri();
+ if (uri != null) {
+ setUri(uri);
+ }
+ return FrequentContactsCursorLoader.super.loadInBackground();
+ }
+ protected abstract Uri getUri();
+ }
+
+ private class PrimaryStrequentContactsQueryStrategy extends StrequentContactsQueryStrategy {
+ @Override
+ protected Uri getUri() {
+ // Use the original URI requested.
+ return mOriginalUri;
+ }
+ }
+
+ private class FrequentOnlyContactsQueryStrategy extends StrequentContactsQueryStrategy {
+ @Override
+ protected Uri getUri() {
+ // Some phones have a buggy implementation of the Contacts provider which crashes
+ // when we query for strequent (starred+frequent) contacts (b/17991485).
+ // If this happens, switch to just querying for frequent contacts.
+ return Contacts.CONTENT_FREQUENT_URI;
+ }
+ }
+
+ private class PhoneOnlyStrequentContactsQueryStrategy extends
+ StrequentContactsQueryStrategy {
+ @Override
+ protected Uri getUri() {
+ // Some 3rd party ROMs have content provider
+ // implementation where invalid SQL queries are returned for regular strequent
+ // queries. Using strequent_phone_only query as a fallback to display only phone
+ // contacts. This is the last-ditch effort; if this fails, we will display an
+ // empty frequent list (b/18354836).
+ final String strequentQueryParam = OsUtil.isAtLeastL() ?
+ ContactsContract.STREQUENT_PHONE_ONLY : "strequent_phone_only";
+ // TODO: Handle enterprise contacts post M once contacts provider supports it
+ return Contacts.CONTENT_STREQUENT_URI.buildUpon()
+ .appendQueryParameter(strequentQueryParam, "true").build();
+ }
+ }
+ }
+
+ public FrequentContactsCursorQueryData(Context context, String[] projection,
+ String selection, String[] selectionArgs, String sortOrder) {
+ // TODO: Handle enterprise contacts post M once contacts provider supports it
+ super(context, Contacts.CONTENT_STREQUENT_URI, projection, selection, selectionArgs,
+ sortOrder);
+ }
+
+ @Override
+ public BoundCursorLoader createBoundCursorLoader(String bindingId) {
+ return new FrequentContactsCursorLoader(bindingId, mContext, mUri, mProjection, mSelection,
+ mSelectionArgs, mSortOrder);
+ }
+}
diff --git a/src/com/android/messaging/datamodel/GalleryBoundCursorLoader.java b/src/com/android/messaging/datamodel/GalleryBoundCursorLoader.java
new file mode 100644
index 0000000..28ec303
--- /dev/null
+++ b/src/com/android/messaging/datamodel/GalleryBoundCursorLoader.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.net.Uri;
+import android.provider.MediaStore.Files;
+import android.provider.MediaStore.Files.FileColumns;
+import android.provider.MediaStore.Images.Media;
+
+import com.android.messaging.datamodel.data.GalleryGridItemData;
+import com.android.messaging.datamodel.data.MessagePartData;
+import com.google.common.base.Joiner;
+
+/**
+ * A BoundCursorLoader that reads local media on the device.
+ */
+public class GalleryBoundCursorLoader extends BoundCursorLoader {
+ public static final String MEDIA_SCANNER_VOLUME_EXTERNAL = "external";
+ private static final Uri STORAGE_URI = Files.getContentUri(MEDIA_SCANNER_VOLUME_EXTERNAL);
+ private static final String SORT_ORDER = Media.DATE_MODIFIED + " DESC";
+ private static final String IMAGE_SELECTION = createSelection(
+ MessagePartData.ACCEPTABLE_IMAGE_TYPES,
+ new Integer[] { FileColumns.MEDIA_TYPE_IMAGE });
+
+ public GalleryBoundCursorLoader(final String bindingId, final Context context) {
+ super(bindingId, context, STORAGE_URI, GalleryGridItemData.IMAGE_PROJECTION,
+ IMAGE_SELECTION, null, SORT_ORDER);
+ }
+
+ private static String createSelection(final String[] mimeTypes, Integer[] mediaTypes) {
+ return Media.MIME_TYPE + " IN ('" + Joiner.on("','").join(mimeTypes) + "') AND "
+ + FileColumns.MEDIA_TYPE + " IN (" + Joiner.on(',').join(mediaTypes) + ")";
+ }
+}
diff --git a/src/com/android/messaging/datamodel/MediaScratchFileProvider.java b/src/com/android/messaging/datamodel/MediaScratchFileProvider.java
new file mode 100644
index 0000000..29ae4f4
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MediaScratchFileProvider.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.database.MatrixCursor.RowBuilder;
+import android.net.Uri;
+import android.provider.OpenableColumns;
+import android.support.v4.util.SimpleArrayMap;
+import android.text.TextUtils;
+
+import com.android.messaging.Factory;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.LogUtil;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * A very simple content provider that can serve media files from our cache directory.
+ */
+public class MediaScratchFileProvider extends FileProvider {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ private static final SimpleArrayMap sUriToDisplayNameMap =
+ new SimpleArrayMap();
+
+ @VisibleForTesting
+ public static final String AUTHORITY =
+ "com.android.messaging.datamodel.MediaScratchFileProvider";
+ private static final String MEDIA_SCRATCH_SPACE_DIR = "mediascratchspace";
+
+ public static boolean isMediaScratchSpaceUri(final Uri uri) {
+ if (uri == null) {
+ return false;
+ }
+
+ final List segments = uri.getPathSegments();
+ return (TextUtils.equals(uri.getScheme(), ContentResolver.SCHEME_CONTENT) &&
+ TextUtils.equals(uri.getAuthority(), AUTHORITY) &&
+ segments.size() == 1 && FileProvider.isValidFileId(segments.get(0)));
+ }
+
+ /**
+ * Returns a uri that can be used to access a raw mms file.
+ *
+ * @return the URI for an raw mms file
+ */
+ public static Uri buildMediaScratchSpaceUri(final String extension) {
+ final Uri uri = FileProvider.buildFileUri(AUTHORITY, extension);
+ final File file = getFileWithExtension(uri.getPath(), extension);
+ if (!ensureFileExists(file)) {
+ LogUtil.e(TAG, "Failed to create temp file " + file.getAbsolutePath());
+ }
+ return uri;
+ }
+
+ public static File getFileFromUri(final Uri uri) {
+ Assert.equals(AUTHORITY, uri.getAuthority());
+ return getFileWithExtension(uri.getPath(), getExtensionFromUri(uri));
+ }
+
+ public static Uri.Builder getUriBuilder() {
+ return (new Uri.Builder()).authority(AUTHORITY).scheme(ContentResolver.SCHEME_CONTENT);
+ }
+
+ @Override
+ File getFile(final String path, final String extension) {
+ return getFileWithExtension(path, extension);
+ }
+
+ private static File getFileWithExtension(final String path, final String extension) {
+ final Context context = Factory.get().getApplicationContext();
+ return new File(getDirectory(context),
+ TextUtils.isEmpty(extension) ? path : path + "." + extension);
+ }
+
+ private static File getDirectory(final Context context) {
+ return new File(context.getCacheDir(), MEDIA_SCRATCH_SPACE_DIR);
+ }
+
+ @Override
+ public Cursor query(final Uri uri, final String[] projection, final String selection,
+ final String[] selectionArgs, final String sortOrder) {
+ if (projection != null && projection.length > 0 &&
+ TextUtils.equals(projection[0], OpenableColumns.DISPLAY_NAME) &&
+ isMediaScratchSpaceUri(uri)) {
+ // Retrieve the display name associated with a temp file. This is used by the Contacts
+ // ImportVCardActivity to retrieve the name of the contact(s) being imported.
+ String displayName;
+ synchronized (sUriToDisplayNameMap) {
+ displayName = sUriToDisplayNameMap.get(uri);
+ }
+ if (!TextUtils.isEmpty(displayName)) {
+ MatrixCursor cursor =
+ new MatrixCursor(new String[] { OpenableColumns.DISPLAY_NAME });
+ RowBuilder row = cursor.newRow();
+ row.add(displayName);
+ return cursor;
+ }
+ }
+ return null;
+ }
+
+ public static void addUriToDisplayNameEntry(final Uri scratchFileUri,
+ final String displayName) {
+ if (TextUtils.isEmpty(displayName)) {
+ return;
+ }
+ synchronized (sUriToDisplayNameMap) {
+ sUriToDisplayNameMap.put(scratchFileUri, displayName);
+ }
+ }
+}
diff --git a/src/com/android/messaging/datamodel/MemoryCacheManager.java b/src/com/android/messaging/datamodel/MemoryCacheManager.java
new file mode 100644
index 0000000..0968cff
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MemoryCacheManager.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import com.android.messaging.Factory;
+
+import java.util.HashSet;
+
+/**
+ * Utility abstraction which allows MemoryCaches in an application to register and then when there
+ * is memory pressure provide a callback to reclaim the memory in the caches.
+ */
+public class MemoryCacheManager {
+ private final HashSet mMemoryCaches = new HashSet();
+ private final Object mMemoryCacheLock = new Object();
+
+ public static MemoryCacheManager get() {
+ return Factory.get().getMemoryCacheManager();
+ }
+
+ /**
+ * Extend this interface to provide a reclaim method on a memory cache.
+ */
+ public interface MemoryCache {
+ void reclaim();
+ }
+
+ /**
+ * Register the memory cache with the application.
+ */
+ public void registerMemoryCache(final MemoryCache cache) {
+ synchronized (mMemoryCacheLock) {
+ mMemoryCaches.add(cache);
+ }
+ }
+
+ /**
+ * Unregister the memory cache with the application.
+ */
+ public void unregisterMemoryCache(final MemoryCache cache) {
+ synchronized (mMemoryCacheLock) {
+ mMemoryCaches.remove(cache);
+ }
+ }
+
+ /**
+ * Reclaim memory in all the memory caches in the application.
+ */
+ @SuppressWarnings("unchecked")
+ public void reclaimMemory() {
+ // We're creating a cache copy in the lock to ensure we're not working on a concurrently
+ // modified set, then reclaim outside of the lock to minimize the time within the lock.
+ final HashSet shallowCopy;
+ synchronized (mMemoryCacheLock) {
+ shallowCopy = (HashSet) mMemoryCaches.clone();
+ }
+ for (final MemoryCache cache : shallowCopy) {
+ cache.reclaim();
+ }
+ }
+}
diff --git a/src/com/android/messaging/datamodel/MessageNotificationState.java b/src/com/android/messaging/datamodel/MessageNotificationState.java
new file mode 100644
index 0000000..0bd4aaa
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MessageNotificationState.java
@@ -0,0 +1,1342 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.graphics.Typeface;
+import android.net.Uri;
+import android.support.v4.app.NotificationCompat;
+import android.support.v4.app.NotificationCompat.Builder;
+import android.support.v4.app.NotificationCompat.WearableExtender;
+import android.support.v4.app.NotificationManagerCompat;
+import android.text.Html;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.ForegroundColorSpan;
+import android.text.style.StyleSpan;
+import android.text.style.TextAppearanceSpan;
+import android.text.style.URLSpan;
+
+import com.android.messaging.Factory;
+import com.android.messaging.R;
+import com.android.messaging.datamodel.data.ConversationListItemData;
+import com.android.messaging.datamodel.data.ConversationMessageData;
+import com.android.messaging.datamodel.data.ConversationParticipantsData;
+import com.android.messaging.datamodel.data.MessageData;
+import com.android.messaging.datamodel.data.MessagePartData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.datamodel.media.VideoThumbnailRequest;
+import com.android.messaging.sms.MmsUtils;
+import com.android.messaging.ui.UIIntents;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.AvatarUriUtil;
+import com.android.messaging.util.BugleGservices;
+import com.android.messaging.util.BugleGservicesKeys;
+import com.android.messaging.util.ContentType;
+import com.android.messaging.util.ConversationIdSet;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.PendingIntentConstants;
+import com.android.messaging.util.UriUtil;
+import com.google.common.collect.Lists;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Notification building class for conversation messages.
+ *
+ * Message Notifications are built in several stages with several utility classes.
+ * 1) Perform a database query and fill a data structure with information on messages and
+ * conversations which need to be notified.
+ * 2) Based on the data structure choose an appropriate NotificationState subclass to
+ * represent all the notifications.
+ * -- For one or more messages in one conversation: MultiMessageNotificationState.
+ * -- For multiple messages in multiple conversations: MultiConversationNotificationState
+ *
+ * A three level structure is used to coalesce the data from the database. From bottom to top:
+ * 1) NotificationLineInfo - A single message that needs to be notified.
+ * 2) ConversationLineInfo - A list of NotificationLineInfo in a single conversation.
+ * 3) ConversationInfoList - A list of ConversationLineInfo and the total number of messages.
+ *
+ * The createConversationInfoList function performs the query and creates the data structure.
+ */
+public abstract class MessageNotificationState extends NotificationState {
+ // Logging
+ static final String TAG = LogUtil.BUGLE_NOTIFICATIONS_TAG;
+ private static final int MAX_MESSAGES_IN_WEARABLE_PAGE = 20;
+
+ private static final int MAX_CHARACTERS_IN_GROUP_NAME = 30;
+
+ private static final int REPLY_INTENT_REQUEST_CODE_OFFSET = 0;
+ private static final int NUM_EXTRA_REQUEST_CODES_NEEDED = 1;
+ protected String mTickerSender = null;
+ protected CharSequence mTickerText = null;
+ protected String mTitle = null;
+ protected CharSequence mContent = null;
+ protected Uri mAttachmentUri = null;
+ protected String mAttachmentType = null;
+ protected boolean mTickerNoContent;
+
+ @Override
+ protected Uri getAttachmentUri() {
+ return mAttachmentUri;
+ }
+
+ @Override
+ protected String getAttachmentType() {
+ return mAttachmentType;
+ }
+
+ @Override
+ public int getIcon() {
+ return R.drawable.ic_sms_light;
+ }
+
+ @Override
+ public int getPriority() {
+ // Returning PRIORITY_HIGH causes L to put up a HUD notification. Without it, the ticker
+ // isn't displayed.
+ return Notification.PRIORITY_HIGH;
+ }
+
+ /**
+ * Base class for single notification events for messages. Multiple of these
+ * may be grouped into a single conversation.
+ */
+ static class NotificationLineInfo {
+
+ final int mNotificationType;
+
+ NotificationLineInfo() {
+ mNotificationType = BugleNotifications.LOCAL_SMS_NOTIFICATION;
+ }
+
+ NotificationLineInfo(final int notificationType) {
+ mNotificationType = notificationType;
+ }
+ }
+
+ /**
+ * Information on a single chat message which should be shown in a notification.
+ */
+ static class MessageLineInfo extends NotificationLineInfo {
+ final CharSequence mText;
+ Uri mAttachmentUri;
+ String mAttachmentType;
+ final String mAuthorFullName;
+ final String mAuthorFirstName;
+ boolean mIsManualDownloadNeeded;
+ final String mMessageId;
+
+ MessageLineInfo(final boolean isGroup, final String authorFullName,
+ final String authorFirstName, final CharSequence text, final Uri attachmentUrl,
+ final String attachmentType, final boolean isManualDownloadNeeded,
+ final String messageId) {
+ super(BugleNotifications.LOCAL_SMS_NOTIFICATION);
+ mAuthorFullName = authorFullName;
+ mAuthorFirstName = authorFirstName;
+ mText = text;
+ mAttachmentUri = attachmentUrl;
+ mAttachmentType = attachmentType;
+ mIsManualDownloadNeeded = isManualDownloadNeeded;
+ mMessageId = messageId;
+ }
+ }
+
+ /**
+ * Information on all the notification messages within a single conversation.
+ */
+ static class ConversationLineInfo {
+ // Conversation id of the latest message in the notification for this merged conversation.
+ final String mConversationId;
+
+ // True if this represents a group conversation.
+ final boolean mIsGroup;
+
+ // Name of the group conversation if available.
+ final String mGroupConversationName;
+
+ // True if this conversation's recipients includes one or more email address(es)
+ // (see ConversationColumns.INCLUDE_EMAIL_ADDRESS)
+ final boolean mIncludeEmailAddress;
+
+ // Timestamp of the latest message
+ final long mReceivedTimestamp;
+
+ // Self participant id.
+ final String mSelfParticipantId;
+
+ // List of individual line notifications to be parsed later.
+ final List mLineInfos;
+
+ // Total number of messages. Might be different that mLineInfos.size() as the number of
+ // line infos is capped.
+ int mTotalMessageCount;
+
+ // Custom ringtone if set
+ final String mRingtoneUri;
+
+ // Should notification be enabled for this conversation?
+ final boolean mNotificationEnabled;
+
+ // Should notifications vibrate for this conversation?
+ final boolean mNotificationVibrate;
+
+ // Avatar uri of sender
+ final Uri mAvatarUri;
+
+ // Contact uri of sender
+ final Uri mContactUri;
+
+ // Subscription id.
+ final int mSubId;
+
+ // Number of participants
+ final int mParticipantCount;
+
+ public ConversationLineInfo(final String conversationId,
+ final boolean isGroup,
+ final String groupConversationName,
+ final boolean includeEmailAddress,
+ final long receivedTimestamp,
+ final String selfParticipantId,
+ final String ringtoneUri,
+ final boolean notificationEnabled,
+ final boolean notificationVibrate,
+ final Uri avatarUri,
+ final Uri contactUri,
+ final int subId,
+ final int participantCount) {
+ mConversationId = conversationId;
+ mIsGroup = isGroup;
+ mGroupConversationName = groupConversationName;
+ mIncludeEmailAddress = includeEmailAddress;
+ mReceivedTimestamp = receivedTimestamp;
+ mSelfParticipantId = selfParticipantId;
+ mLineInfos = new ArrayList();
+ mTotalMessageCount = 0;
+ mRingtoneUri = ringtoneUri;
+ mAvatarUri = avatarUri;
+ mContactUri = contactUri;
+ mNotificationEnabled = notificationEnabled;
+ mNotificationVibrate = notificationVibrate;
+ mSubId = subId;
+ mParticipantCount = participantCount;
+ }
+
+ public int getLatestMessageNotificationType() {
+ final MessageLineInfo messageLineInfo = getLatestMessageLineInfo();
+ if (messageLineInfo == null) {
+ return BugleNotifications.LOCAL_SMS_NOTIFICATION;
+ }
+ return messageLineInfo.mNotificationType;
+ }
+
+ public String getLatestMessageId() {
+ final MessageLineInfo messageLineInfo = getLatestMessageLineInfo();
+ if (messageLineInfo == null) {
+ return null;
+ }
+ return messageLineInfo.mMessageId;
+ }
+
+ public boolean getDoesLatestMessageNeedDownload() {
+ final MessageLineInfo messageLineInfo = getLatestMessageLineInfo();
+ if (messageLineInfo == null) {
+ return false;
+ }
+ return messageLineInfo.mIsManualDownloadNeeded;
+ }
+
+ private MessageLineInfo getLatestMessageLineInfo() {
+ // The latest message is stored at index zero of the message line infos.
+ if (mLineInfos.size() > 0 && mLineInfos.get(0) instanceof MessageLineInfo) {
+ return (MessageLineInfo) mLineInfos.get(0);
+ }
+ return null;
+ }
+ }
+
+ /**
+ * Information on all the notification messages across all conversations.
+ */
+ public static class ConversationInfoList {
+ final int mMessageCount;
+ final List mConvInfos;
+ public ConversationInfoList(final int count, final List infos) {
+ mMessageCount = count;
+ mConvInfos = infos;
+ }
+ }
+
+ final ConversationInfoList mConvList;
+ private long mLatestReceivedTimestamp;
+
+ private static ConversationIdSet makeConversationIdSet(final ConversationInfoList convList) {
+ ConversationIdSet set = null;
+ if (convList != null && convList.mConvInfos != null && convList.mConvInfos.size() > 0) {
+ set = new ConversationIdSet();
+ for (final ConversationLineInfo info : convList.mConvInfos) {
+ set.add(info.mConversationId);
+ }
+ }
+ return set;
+ }
+
+ protected MessageNotificationState(final ConversationInfoList convList) {
+ super(makeConversationIdSet(convList));
+ mConvList = convList;
+ mType = PendingIntentConstants.SMS_NOTIFICATION_ID;
+ mLatestReceivedTimestamp = Long.MIN_VALUE;
+ if (convList != null) {
+ for (final ConversationLineInfo info : convList.mConvInfos) {
+ mLatestReceivedTimestamp = Math.max(mLatestReceivedTimestamp,
+ info.mReceivedTimestamp);
+ }
+ }
+ }
+
+ @Override
+ public long getLatestReceivedTimestamp() {
+ return mLatestReceivedTimestamp;
+ }
+
+ @Override
+ public int getNumRequestCodesNeeded() {
+ // Get additional request codes for the Reply PendingIntent (wearables only)
+ // and the DND PendingIntent.
+ return super.getNumRequestCodesNeeded() + NUM_EXTRA_REQUEST_CODES_NEEDED;
+ }
+
+ private int getBaseExtraRequestCode() {
+ return mBaseRequestCode + super.getNumRequestCodesNeeded();
+ }
+
+ public int getReplyIntentRequestCode() {
+ return getBaseExtraRequestCode() + REPLY_INTENT_REQUEST_CODE_OFFSET;
+ }
+
+ @Override
+ public PendingIntent getClearIntent() {
+ return UIIntents.get().getPendingIntentForClearingNotifications(
+ Factory.get().getApplicationContext(),
+ BugleNotifications.UPDATE_MESSAGES,
+ mConversationIds,
+ getClearIntentRequestCode());
+ }
+
+ /**
+ * Notification for multiple messages in at least 2 different conversations.
+ */
+ public static class MultiConversationNotificationState extends MessageNotificationState {
+
+ public final List
+ mChildren = new ArrayList();
+
+ public MultiConversationNotificationState(
+ final ConversationInfoList convList, final MessageNotificationState state) {
+ super(convList);
+ mAttachmentUri = null;
+ mAttachmentType = null;
+
+ // Pull the ticker title/text from the single notification
+ mTickerSender = state.getTitle();
+ mTitle = Factory.get().getApplicationContext().getResources().getQuantityString(
+ R.plurals.notification_new_messages,
+ convList.mMessageCount, convList.mMessageCount);
+ mTickerText = state.mContent;
+
+ // Create child notifications for each conversation,
+ // which will be displayed (only) on a wearable device.
+ for (int i = 0; i < convList.mConvInfos.size(); i++) {
+ final ConversationLineInfo convInfo = convList.mConvInfos.get(i);
+ if (!(convInfo.mLineInfos.get(0) instanceof MessageLineInfo)) {
+ continue;
+ }
+ setPeopleForConversation(convInfo.mConversationId);
+ final ConversationInfoList list = new ConversationInfoList(
+ convInfo.mTotalMessageCount, Lists.newArrayList(convInfo));
+ mChildren.add(new BundledMessageNotificationState(list, i));
+ }
+ }
+
+ @Override
+ public int getIcon() {
+ return R.drawable.ic_sms_multi_light;
+ }
+
+ @Override
+ protected NotificationCompat.Style build(final Builder builder) {
+ builder.setContentTitle(mTitle);
+ NotificationCompat.InboxStyle inboxStyle = null;
+ inboxStyle = new NotificationCompat.InboxStyle(builder);
+
+ final Context context = Factory.get().getApplicationContext();
+ // enumeration_comma is defined as ", "
+ final String separator = context.getString(R.string.enumeration_comma);
+ final StringBuilder senders = new StringBuilder();
+ long when = 0;
+ for (int i = 0; i < mConvList.mConvInfos.size(); i++) {
+ final ConversationLineInfo convInfo = mConvList.mConvInfos.get(i);
+ if (convInfo.mReceivedTimestamp > when) {
+ when = convInfo.mReceivedTimestamp;
+ }
+ String sender;
+ CharSequence text;
+ final NotificationLineInfo lineInfo = convInfo.mLineInfos.get(0);
+ final MessageLineInfo messageLineInfo = (MessageLineInfo) lineInfo;
+ if (convInfo.mIsGroup) {
+ sender = (convInfo.mGroupConversationName.length() >
+ MAX_CHARACTERS_IN_GROUP_NAME) ?
+ truncateGroupMessageName(convInfo.mGroupConversationName)
+ : convInfo.mGroupConversationName;
+ } else {
+ sender = messageLineInfo.mAuthorFullName;
+ }
+ text = messageLineInfo.mText;
+ mAttachmentUri = messageLineInfo.mAttachmentUri;
+ mAttachmentType = messageLineInfo.mAttachmentType;
+
+ inboxStyle.addLine(BugleNotifications.formatInboxMessage(
+ sender, text, mAttachmentUri, mAttachmentType));
+ if (sender != null) {
+ if (senders.length() > 0) {
+ senders.append(separator);
+ }
+ senders.append(sender);
+ }
+ }
+ // for collapsed state
+ mContent = senders;
+ builder.setContentText(senders)
+ .setTicker(getTicker())
+ .setWhen(when);
+
+ return inboxStyle;
+ }
+ }
+
+ /**
+ * Truncate group conversation name to be displayed in the notifications. This either truncates
+ * the entire group name or finds the last comma in the available length and truncates the name
+ * at that point
+ */
+ private static String truncateGroupMessageName(final String conversationName) {
+ int endIndex = MAX_CHARACTERS_IN_GROUP_NAME;
+ for (int i = MAX_CHARACTERS_IN_GROUP_NAME; i >= 0; i--) {
+ // The dividing marker should stay consistent with ConversationListItemData.DIVIDER_TEXT
+ if (conversationName.charAt(i) == ',') {
+ endIndex = i;
+ break;
+ }
+ }
+ return conversationName.substring(0, endIndex) + '\u2026';
+ }
+
+ /**
+ * Notification for multiple messages in a single conversation. Also used if there is a single
+ * message in a single conversation.
+ */
+ public static class MultiMessageNotificationState extends MessageNotificationState {
+
+ public MultiMessageNotificationState(final ConversationInfoList convList) {
+ super(convList);
+ // This conversation has been accepted.
+ final ConversationLineInfo convInfo = convList.mConvInfos.get(0);
+ setAvatarUrlsForConversation(convInfo.mConversationId);
+ setPeopleForConversation(convInfo.mConversationId);
+
+ final Context context = Factory.get().getApplicationContext();
+ MessageLineInfo messageInfo = (MessageLineInfo) convInfo.mLineInfos.get(0);
+ // attached photo
+ mAttachmentUri = messageInfo.mAttachmentUri;
+ mAttachmentType = messageInfo.mAttachmentType;
+ mContent = messageInfo.mText;
+
+ if (mAttachmentUri != null) {
+ // The default attachment type is an image, since that's what was originally
+ // supported. When there's no content type, assume it's an image.
+ int message = R.string.notification_picture;
+ if (ContentType.isAudioType(mAttachmentType)) {
+ message = R.string.notification_audio;
+ } else if (ContentType.isVideoType(mAttachmentType)) {
+ message = R.string.notification_video;
+ } else if (ContentType.isVCardType(mAttachmentType)) {
+ message = R.string.notification_vcard;
+ }
+ final String attachment = context.getString(message);
+ final SpannableStringBuilder spanBuilder = new SpannableStringBuilder();
+ if (!TextUtils.isEmpty(mContent)) {
+ spanBuilder.append(mContent).append(System.getProperty("line.separator"));
+ }
+ final int start = spanBuilder.length();
+ spanBuilder.append(attachment);
+ spanBuilder.setSpan(new StyleSpan(Typeface.ITALIC), start, spanBuilder.length(),
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ mContent = spanBuilder;
+ }
+ if (convInfo.mIsGroup) {
+ // When the message is part of a group, the sender's first name
+ // is prepended to the message, but not for the ticker message.
+ mTickerText = mContent;
+ mTickerSender = messageInfo.mAuthorFullName;
+ // append the bold name to the front of the message
+ mContent = BugleNotifications.buildSpaceSeparatedMessage(
+ messageInfo.mAuthorFullName, mContent, mAttachmentUri,
+ mAttachmentType);
+ mTitle = convInfo.mGroupConversationName;
+ } else {
+ // No matter how many messages there are, since this is a 1:1, just
+ // get the author full name from the first one.
+ messageInfo = (MessageLineInfo) convInfo.mLineInfos.get(0);
+ mTitle = messageInfo.mAuthorFullName;
+ }
+ }
+
+ @Override
+ protected NotificationCompat.Style build(final Builder builder) {
+ builder.setContentTitle(mTitle)
+ .setTicker(getTicker());
+
+ NotificationCompat.Style notifStyle = null;
+ final ConversationLineInfo convInfo = mConvList.mConvInfos.get(0);
+ final List lineInfos = convInfo.mLineInfos;
+ final int messageCount = lineInfos.size();
+ // At this point, all the messages come from the same conversation. We need to load
+ // the sender's avatar and then finish building the notification on a callback.
+
+ builder.setContentText(mContent); // for collapsed state
+
+ if (messageCount == 1) {
+ final boolean shouldShowImage = ContentType.isImageType(mAttachmentType)
+ || (ContentType.isVideoType(mAttachmentType)
+ && VideoThumbnailRequest.shouldShowIncomingVideoThumbnails());
+ if (mAttachmentUri != null && shouldShowImage) {
+ // Show "Picture" as the content
+ final MessageLineInfo messageLineInfo = (MessageLineInfo) lineInfos.get(0);
+ String authorFirstName = messageLineInfo.mAuthorFirstName;
+
+ // For the collapsed state, just show "picture" unless this is a
+ // group conversation. If it's a group, show the sender name and
+ // "picture".
+ final CharSequence tickerTag =
+ BugleNotifications.formatAttachmentTag(authorFirstName,
+ mAttachmentType);
+ // For 1:1 notifications don't show first name in the notification, but
+ // do show it in the ticker text
+ CharSequence pictureTag = tickerTag;
+ if (!convInfo.mIsGroup) {
+ authorFirstName = null;
+ pictureTag = BugleNotifications.formatAttachmentTag(authorFirstName,
+ mAttachmentType);
+ }
+ builder.setContentText(pictureTag);
+ builder.setTicker(tickerTag);
+
+ notifStyle = new NotificationCompat.BigPictureStyle(builder)
+ .setSummaryText(BugleNotifications.formatInboxMessage(
+ authorFirstName,
+ null, null,
+ null)); // expanded state, just show sender
+ } else {
+ notifStyle = new NotificationCompat.BigTextStyle(builder)
+ .bigText(mContent);
+ }
+ } else {
+ // We've got multiple messages for the same sender.
+ // Starting with the oldest new message, display the full text of each message.
+ // Begin a line for each subsequent message.
+ final SpannableStringBuilder buf = new SpannableStringBuilder();
+
+ for (int i = lineInfos.size() - 1; i >= 0; --i) {
+ final NotificationLineInfo info = lineInfos.get(i);
+ final MessageLineInfo messageLineInfo = (MessageLineInfo) info;
+ mAttachmentUri = messageLineInfo.mAttachmentUri;
+ mAttachmentType = messageLineInfo.mAttachmentType;
+ CharSequence text = messageLineInfo.mText;
+ if (!TextUtils.isEmpty(text) || mAttachmentUri != null) {
+ if (convInfo.mIsGroup) {
+ // append the bold name to the front of the message
+ text = BugleNotifications.buildSpaceSeparatedMessage(
+ messageLineInfo.mAuthorFullName, text, mAttachmentUri,
+ mAttachmentType);
+ } else {
+ text = BugleNotifications.buildSpaceSeparatedMessage(
+ null, text, mAttachmentUri, mAttachmentType);
+ }
+ buf.append(text);
+ if (i > 0) {
+ buf.append('\n');
+ }
+ }
+ }
+
+ // Show a single notification -- big style with the text of all the messages
+ notifStyle = new NotificationCompat.BigTextStyle(builder).bigText(buf);
+ }
+ builder.setWhen(convInfo.mReceivedTimestamp);
+ return notifStyle;
+ }
+
+ }
+
+ private static boolean firstNameUsedMoreThanOnce(
+ final HashMap map, final String firstName) {
+ if (map == null) {
+ return false;
+ }
+ if (firstName == null) {
+ return false;
+ }
+ final Integer count = map.get(firstName);
+ if (count != null) {
+ return count > 1;
+ } else {
+ return false;
+ }
+ }
+
+ private static HashMap scanFirstNames(final String conversationId) {
+ final Context context = Factory.get().getApplicationContext();
+ final Uri uri =
+ MessagingContentProvider.buildConversationParticipantsUri(conversationId);
+ final Cursor participantsCursor = context.getContentResolver().query(
+ uri, ParticipantData.ParticipantsQuery.PROJECTION, null, null, null);
+ final ConversationParticipantsData participantsData = new ConversationParticipantsData();
+ participantsData.bind(participantsCursor);
+ final Iterator iter = participantsData.iterator();
+
+ final HashMap firstNames = new HashMap();
+ boolean seenSelf = false;
+ while (iter.hasNext()) {
+ final ParticipantData participant = iter.next();
+ // Make sure we only add the self participant once
+ if (participant.isSelf()) {
+ if (seenSelf) {
+ continue;
+ } else {
+ seenSelf = true;
+ }
+ }
+
+ final String firstName = participant.getFirstName();
+ if (firstName == null) {
+ continue;
+ }
+
+ final int currentCount = firstNames.containsKey(firstName)
+ ? firstNames.get(firstName)
+ : 0;
+ firstNames.put(firstName, currentCount + 1);
+ }
+ return firstNames;
+ }
+
+ // Essentially, we're building a list of the past 20 messages for this conversation to display
+ // on the wearable.
+ public static Notification buildConversationPageForWearable(final String conversationId,
+ int participantCount) {
+ final Context context = Factory.get().getApplicationContext();
+
+ // Limit the number of messages to show. We just want enough to provide context for the
+ // notification. Fetch one more than we need, so we can tell if there are more messages
+ // before the one we're showing.
+ // TODO: in the query, a multipart message will contain a row for each part.
+ // We might need a smarter GROUP_BY. On the other hand, we might want to show each of the
+ // parts as separate messages on the wearable.
+ final int limit = MAX_MESSAGES_IN_WEARABLE_PAGE + 1;
+
+ final List messages = Lists.newArrayList();
+ boolean hasSeenMessagesBeforeNotification = false;
+ Cursor convMessageCursor = null;
+ try {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ final String[] queryArgs = { conversationId };
+ final String convPageSql = ConversationMessageData.getWearableQuerySql() + " LIMIT " +
+ limit;
+ convMessageCursor = db.rawQuery(
+ convPageSql,
+ queryArgs);
+
+ if (convMessageCursor == null || !convMessageCursor.moveToFirst()) {
+ return null;
+ }
+ final ConversationMessageData convMessageData =
+ new ConversationMessageData();
+
+ final HashMap firstNames = scanFirstNames(conversationId);
+ do {
+ convMessageData.bind(convMessageCursor);
+
+ final String authorFullName = convMessageData.getSenderFullName();
+ final String authorFirstName = convMessageData.getSenderFirstName();
+ String text = convMessageData.getText();
+
+ final boolean isSmsPushNotification = convMessageData.getIsMmsNotification();
+
+ // if auto-download was off to show a message to tap to download the message. We
+ // might need to get that working again.
+ if (isSmsPushNotification && text != null) {
+ text = convertHtmlAndStripUrls(text).toString();
+ }
+ // Skip messages without any content
+ if (TextUtils.isEmpty(text) && !convMessageData.hasAttachments()) {
+ continue;
+ }
+ // Track whether there are messages prior to the one(s) shown in the notification.
+ if (convMessageData.getIsSeen()) {
+ hasSeenMessagesBeforeNotification = true;
+ }
+
+ final boolean usedMoreThanOnce = firstNameUsedMoreThanOnce(
+ firstNames, authorFirstName);
+ String displayName = usedMoreThanOnce ? authorFullName : authorFirstName;
+ if (TextUtils.isEmpty(displayName)) {
+ if (convMessageData.getIsIncoming()) {
+ displayName = convMessageData.getSenderDisplayDestination();
+ if (TextUtils.isEmpty(displayName)) {
+ displayName = context.getString(R.string.unknown_sender);
+ }
+ } else {
+ displayName = context.getString(R.string.unknown_self_participant);
+ }
+ }
+
+ Uri attachmentUri = null;
+ String attachmentType = null;
+ final List attachments = convMessageData.getAttachments();
+ for (final MessagePartData messagePartData : attachments) {
+ // Look for the first attachment that's not the text piece.
+ if (!messagePartData.isText()) {
+ attachmentUri = messagePartData.getContentUri();
+ attachmentType = messagePartData.getContentType();
+ break;
+ }
+ }
+
+ final CharSequence message = BugleNotifications.buildSpaceSeparatedMessage(
+ displayName, text, attachmentUri, attachmentType);
+ messages.add(message);
+
+ } while (convMessageCursor.moveToNext());
+ } finally {
+ if (convMessageCursor != null) {
+ convMessageCursor.close();
+ }
+ }
+
+ // If there is no conversation history prior to what is already visible in the main
+ // notification, there's no need to include the conversation log, too.
+ final int maxMessagesInNotification = getMaxMessagesInConversationNotification();
+ if (!hasSeenMessagesBeforeNotification && messages.size() <= maxMessagesInNotification) {
+ return null;
+ }
+
+ final SpannableStringBuilder bigText = new SpannableStringBuilder();
+ // There is at least 1 message prior to the first one that we're going to show.
+ // Indicate this by inserting an ellipsis at the beginning of the conversation log.
+ if (convMessageCursor.getCount() == limit) {
+ bigText.append(context.getString(R.string.ellipsis) + "\n\n");
+ if (messages.size() > MAX_MESSAGES_IN_WEARABLE_PAGE) {
+ messages.remove(messages.size() - 1);
+ }
+ }
+ // Messages are sorted in descending timestamp order, so iterate backwards
+ // to get them back in ascending order for display purposes.
+ for (int i = messages.size() - 1; i >= 0; --i) {
+ bigText.append(messages.get(i));
+ if (i > 0) {
+ bigText.append("\n\n");
+ }
+ }
+ ++participantCount; // Add in myself
+
+ if (participantCount > 2) {
+ final SpannableString statusText = new SpannableString(
+ context.getResources().getQuantityString(R.plurals.wearable_participant_count,
+ participantCount, participantCount));
+ statusText.setSpan(new ForegroundColorSpan(context.getResources().getColor(
+ R.color.wearable_notification_participants_count)), 0, statusText.length(),
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ bigText.append("\n\n").append(statusText);
+ }
+
+ final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context);
+ final NotificationCompat.Style notifStyle =
+ new NotificationCompat.BigTextStyle(notifBuilder).bigText(bigText);
+ notifBuilder.setStyle(notifStyle);
+
+ final WearableExtender wearableExtender = new WearableExtender();
+ wearableExtender.setStartScrollBottom(true);
+ notifBuilder.extend(wearableExtender);
+
+ return notifBuilder.build();
+ }
+
+ /**
+ * Notification for one or more messages in a single conversation, which is bundled together
+ * with notifications for other conversations on a wearable device.
+ */
+ public static class BundledMessageNotificationState extends MultiMessageNotificationState {
+ public int mGroupOrder;
+ public BundledMessageNotificationState(final ConversationInfoList convList,
+ final int groupOrder) {
+ super(convList);
+ mGroupOrder = groupOrder;
+ }
+ }
+
+ /**
+ * Performs a query on the database.
+ */
+ private static ConversationInfoList createConversationInfoList() {
+ // Map key is conversation id. We use LinkedHashMap to ensure that entries are iterated in
+ // the same order they were originally added. We scan unseen messages from newest to oldest,
+ // so the corresponding conversations are added in that order, too.
+ final Map convLineInfos = new LinkedHashMap<>();
+ int messageCount = 0;
+
+ Cursor convMessageCursor = null;
+ try {
+ final Context context = Factory.get().getApplicationContext();
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ convMessageCursor = db.rawQuery(
+ ConversationMessageData.getNotificationQuerySql(),
+ null);
+
+ if (convMessageCursor != null && convMessageCursor.moveToFirst()) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "MessageNotificationState: Found unseen message notifications.");
+ }
+ final ConversationMessageData convMessageData =
+ new ConversationMessageData();
+
+ HashMap firstNames = null;
+ String conversationIdForFirstNames = null;
+ String groupConversationName = null;
+ final int maxMessages = getMaxMessagesInConversationNotification();
+
+ do {
+ convMessageData.bind(convMessageCursor);
+
+ // First figure out if this is a valid message.
+ String authorFullName = convMessageData.getSenderFullName();
+ String authorFirstName = convMessageData.getSenderFirstName();
+ final String messageText = convMessageData.getText();
+
+ final String convId = convMessageData.getConversationId();
+ final String messageId = convMessageData.getMessageId();
+
+ CharSequence text = messageText;
+ final boolean isManualDownloadNeeded = convMessageData.getIsMmsNotification();
+ if (isManualDownloadNeeded) {
+ // Don't try and convert the text from html if it's sms and not a sms push
+ // notification.
+ Assert.equals(MessageData.BUGLE_STATUS_INCOMING_YET_TO_MANUAL_DOWNLOAD,
+ convMessageData.getStatus());
+ text = context.getResources().getString(
+ R.string.message_title_manual_download);
+ }
+ ConversationLineInfo currConvInfo = convLineInfos.get(convId);
+ if (currConvInfo == null) {
+ final ConversationListItemData convData =
+ ConversationListItemData.getExistingConversation(db, convId);
+ if (!convData.getNotificationEnabled()) {
+ // Skip conversations that have notifications disabled.
+ continue;
+ }
+ final int subId = BugleDatabaseOperations.getSelfSubscriptionId(db,
+ convData.getSelfId());
+ groupConversationName = convData.getName();
+ final Uri avatarUri = AvatarUriUtil.createAvatarUri(
+ convMessageData.getSenderProfilePhotoUri(),
+ convMessageData.getSenderFullName(),
+ convMessageData.getSenderNormalizedDestination(),
+ convMessageData.getSenderContactLookupKey());
+ currConvInfo = new ConversationLineInfo(convId,
+ convData.getIsGroup(),
+ groupConversationName,
+ convData.getIncludeEmailAddress(),
+ convMessageData.getReceivedTimeStamp(),
+ convData.getSelfId(),
+ convData.getNotificationSoundUri(),
+ convData.getNotificationEnabled(),
+ convData.getNotifiationVibrate(),
+ avatarUri,
+ convMessageData.getSenderContactLookupUri(),
+ subId,
+ convData.getParticipantCount());
+ convLineInfos.put(convId, currConvInfo);
+ }
+ // Prepare the message line
+ if (currConvInfo.mTotalMessageCount < maxMessages) {
+ if (currConvInfo.mIsGroup) {
+ if (authorFirstName == null) {
+ // authorFullName might be null as well. In that case, we won't
+ // show an author. That is better than showing all the group
+ // names again on the 2nd line.
+ authorFirstName = authorFullName;
+ }
+ } else {
+ // don't recompute this if we don't need to
+ if (!TextUtils.equals(conversationIdForFirstNames, convId)) {
+ firstNames = scanFirstNames(convId);
+ conversationIdForFirstNames = convId;
+ }
+ if (firstNames != null) {
+ final Integer count = firstNames.get(authorFirstName);
+ if (count != null && count > 1) {
+ authorFirstName = authorFullName;
+ }
+ }
+
+ if (authorFullName == null) {
+ authorFullName = groupConversationName;
+ }
+ if (authorFirstName == null) {
+ authorFirstName = groupConversationName;
+ }
+ }
+ final String subjectText = MmsUtils.cleanseMmsSubject(
+ context.getResources(),
+ convMessageData.getMmsSubject());
+ if (!TextUtils.isEmpty(subjectText)) {
+ final String subjectLabel =
+ context.getString(R.string.subject_label);
+ final SpannableStringBuilder spanBuilder =
+ new SpannableStringBuilder();
+
+ spanBuilder.append(context.getString(R.string.notification_subject,
+ subjectLabel, subjectText));
+ spanBuilder.setSpan(new TextAppearanceSpan(
+ context, R.style.NotificationSubjectText), 0,
+ subjectLabel.length(),
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ if (!TextUtils.isEmpty(text)) {
+ // Now add the actual message text below the subject header.
+ spanBuilder.append(System.getProperty("line.separator") + text);
+ }
+ text = spanBuilder;
+ }
+ // If we've got attachments, find the best one. If one of the messages is
+ // a photo, save the url so we'll display a big picture notification.
+ // Otherwise, show the first one we find.
+ Uri attachmentUri = null;
+ String attachmentType = null;
+ final MessagePartData messagePartData =
+ getMostInterestingAttachment(convMessageData);
+ if (messagePartData != null) {
+ attachmentUri = messagePartData.getContentUri();
+ attachmentType = messagePartData.getContentType();
+ }
+ currConvInfo.mLineInfos.add(new MessageLineInfo(currConvInfo.mIsGroup,
+ authorFullName, authorFirstName, text,
+ attachmentUri, attachmentType, isManualDownloadNeeded, messageId));
+ }
+ messageCount++;
+ currConvInfo.mTotalMessageCount++;
+ } while (convMessageCursor.moveToNext());
+ }
+ } finally {
+ if (convMessageCursor != null) {
+ convMessageCursor.close();
+ }
+ }
+ if (convLineInfos.isEmpty()) {
+ return null;
+ } else {
+ return new ConversationInfoList(messageCount,
+ Lists.newLinkedList(convLineInfos.values()));
+ }
+ }
+
+ /**
+ * Scans all the attachments for a message and returns the most interesting one that we'll
+ * show in a notification. By order of importance, in case there are multiple attachments:
+ * 1- an image (because we can show the image as a BigPictureNotification)
+ * 2- a video (because we can show a video frame as a BigPictureNotification)
+ * 3- a vcard
+ * 4- an audio attachment
+ * @return MessagePartData for the most interesting part. Can be null.
+ */
+ private static MessagePartData getMostInterestingAttachment(
+ final ConversationMessageData convMessageData) {
+ final List attachments = convMessageData.getAttachments();
+
+ MessagePartData imagePart = null;
+ MessagePartData audioPart = null;
+ MessagePartData vcardPart = null;
+ MessagePartData videoPart = null;
+
+ // 99.99% of the time there will be 0 or 1 part, since receiving slideshows is so
+ // uncommon.
+
+ // Remember the first of each type of part.
+ for (final MessagePartData messagePartData : attachments) {
+ if (messagePartData.isImage() && imagePart == null) {
+ imagePart = messagePartData;
+ }
+ if (messagePartData.isVideo() && videoPart == null) {
+ videoPart = messagePartData;
+ }
+ if (messagePartData.isVCard() && vcardPart == null) {
+ vcardPart = messagePartData;
+ }
+ if (messagePartData.isAudio() && audioPart == null) {
+ audioPart = messagePartData;
+ }
+ }
+ if (imagePart != null) {
+ return imagePart;
+ } else if (videoPart != null) {
+ return videoPart;
+ } else if (audioPart != null) {
+ return audioPart;
+ } else if (vcardPart != null) {
+ return vcardPart;
+ }
+ return null;
+ }
+
+ private static int getMaxMessagesInConversationNotification() {
+ if (!BugleNotifications.isWearCompanionAppInstalled()) {
+ return BugleGservices.get().getInt(
+ BugleGservicesKeys.MAX_MESSAGES_IN_CONVERSATION_NOTIFICATION,
+ BugleGservicesKeys.MAX_MESSAGES_IN_CONVERSATION_NOTIFICATION_DEFAULT);
+ }
+ return BugleGservices.get().getInt(
+ BugleGservicesKeys.MAX_MESSAGES_IN_CONVERSATION_NOTIFICATION_WITH_WEARABLE,
+ BugleGservicesKeys.MAX_MESSAGES_IN_CONVERSATION_NOTIFICATION_WITH_WEARABLE_DEFAULT);
+ }
+
+ /**
+ * Scans the database for messages that need to go into notifications. Creates the appropriate
+ * MessageNotificationState depending on if there are multiple senders, or
+ * messages from one sender.
+ * @return NotificationState for the notification created.
+ */
+ public static NotificationState getNotificationState() {
+ MessageNotificationState state = null;
+ final ConversationInfoList convList = createConversationInfoList();
+
+ if (convList == null || convList.mConvInfos.size() == 0) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "MessageNotificationState: No unseen notifications");
+ }
+ } else {
+ final ConversationLineInfo convInfo = convList.mConvInfos.get(0);
+ state = new MultiMessageNotificationState(convList);
+
+ if (convList.mConvInfos.size() > 1) {
+ // We've got notifications across multiple conversations. Pass in the notification
+ // we just built of the most recent notification so we can use that to show the
+ // user the new message in the ticker.
+ state = new MultiConversationNotificationState(convList, state);
+ } else {
+ // For now, only show avatars for notifications for a single conversation.
+ if (convInfo.mAvatarUri != null) {
+ if (state.mParticipantAvatarsUris == null) {
+ state.mParticipantAvatarsUris = new ArrayList(1);
+ }
+ state.mParticipantAvatarsUris.add(convInfo.mAvatarUri);
+ }
+ if (convInfo.mContactUri != null) {
+ if (state.mParticipantContactUris == null) {
+ state.mParticipantContactUris = new ArrayList(1);
+ }
+ state.mParticipantContactUris.add(convInfo.mContactUri);
+ }
+ }
+ }
+ if (state != null && LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "MessageNotificationState: Notification state created"
+ + ", title = " + LogUtil.sanitizePII(state.mTitle)
+ + ", content = " + LogUtil.sanitizePII(state.mContent.toString()));
+ }
+ return state;
+ }
+
+ protected String getTitle() {
+ return mTitle;
+ }
+
+ @Override
+ public int getLatestMessageNotificationType() {
+ // This function is called to determine whether the most recent notification applies
+ // to an sms conversation or a hangout conversation. We have different ringtone/vibrate
+ // settings for both types of conversations.
+ if (mConvList.mConvInfos.size() > 0) {
+ final ConversationLineInfo convInfo = mConvList.mConvInfos.get(0);
+ return convInfo.getLatestMessageNotificationType();
+ }
+ return BugleNotifications.LOCAL_SMS_NOTIFICATION;
+ }
+
+ @Override
+ public String getRingtoneUri() {
+ if (mConvList.mConvInfos.size() > 0) {
+ return mConvList.mConvInfos.get(0).mRingtoneUri;
+ }
+ return null;
+ }
+
+ @Override
+ public boolean getNotificationVibrate() {
+ if (mConvList.mConvInfos.size() > 0) {
+ return mConvList.mConvInfos.get(0).mNotificationVibrate;
+ }
+ return false;
+ }
+
+ protected CharSequence getTicker() {
+ return BugleNotifications.buildColonSeparatedMessage(
+ mTickerSender != null ? mTickerSender : mTitle,
+ mTickerText != null ? mTickerText : (mTickerNoContent ? null : mContent), null,
+ null);
+ }
+
+ private static CharSequence convertHtmlAndStripUrls(final String s) {
+ final Spanned text = Html.fromHtml(s);
+ if (text instanceof Spannable) {
+ stripUrls((Spannable) text);
+ }
+ return text;
+ }
+
+ // Since we don't want to show URLs in notifications, a function
+ // to remove them in place.
+ private static void stripUrls(final Spannable text) {
+ final URLSpan[] spans = text.getSpans(0, text.length(), URLSpan.class);
+ for (final URLSpan span : spans) {
+ text.removeSpan(span);
+ }
+ }
+
+ /*
+ private static void updateAlertStatusMessages(final long thresholdDeltaMs) {
+ // TODO may need this when supporting error notifications
+ final EsDatabaseHelper helper = EsDatabaseHelper.getDatabaseHelper();
+ final ContentValues values = new ContentValues();
+ final long nowMicros = System.currentTimeMillis() * 1000;
+ values.put(MessageColumns.ALERT_STATUS, "1");
+ final String selection =
+ MessageColumns.ALERT_STATUS + "=0 AND (" +
+ MessageColumns.STATUS + "=" + EsProvider.MESSAGE_STATUS_FAILED_TO_SEND + " OR (" +
+ MessageColumns.STATUS + "!=" + EsProvider.MESSAGE_STATUS_ON_SERVER + " AND " +
+ MessageColumns.TIMESTAMP + "+" + thresholdDeltaMs*1000 + "<" + nowMicros + ")) ";
+
+ final int updateCount = helper.getWritableDatabaseWrapper().update(
+ EsProvider.MESSAGES_TABLE,
+ values,
+ selection,
+ null);
+ if (updateCount > 0) {
+ EsConversationsData.notifyConversationsChanged();
+ }
+ }*/
+
+ static CharSequence applyWarningTextColor(final Context context,
+ final CharSequence text) {
+ if (text == null) {
+ return null;
+ }
+ final SpannableStringBuilder spanBuilder = new SpannableStringBuilder();
+ spanBuilder.append(text);
+ spanBuilder.setSpan(new ForegroundColorSpan(context.getResources().getColor(
+ R.color.notification_warning_color)), 0, text.length(),
+ Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ return spanBuilder;
+ }
+
+ /**
+ * Check for failed messages and post notifications as needed.
+ * TODO: Rewrite this as a NotificationState.
+ */
+ public static void checkFailedMessages() {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ final Cursor messageDataCursor = db.query(DatabaseHelper.MESSAGES_TABLE,
+ MessageData.getProjection(),
+ FailedMessageQuery.FAILED_MESSAGES_WHERE_CLAUSE,
+ null /*selectionArgs*/,
+ null /*groupBy*/,
+ null /*having*/,
+ FailedMessageQuery.FAILED_ORDER_BY);
+
+ try {
+ final Context context = Factory.get().getApplicationContext();
+ final Resources resources = context.getResources();
+ final NotificationManagerCompat notificationManager =
+ NotificationManagerCompat.from(context);
+ if (messageDataCursor != null) {
+ final MessageData messageData = new MessageData();
+
+ final HashSet conversationsWithFailedMessages = new HashSet();
+
+ // track row ids in case we want to display something that requires this
+ // information
+ final ArrayList failedMessages = new ArrayList();
+
+ int cursorPosition = -1;
+ final long when = 0;
+
+ messageDataCursor.moveToPosition(-1);
+ while (messageDataCursor.moveToNext()) {
+ messageData.bind(messageDataCursor);
+
+ final String conversationId = messageData.getConversationId();
+ if (DataModel.get().isNewMessageObservable(conversationId)) {
+ // Don't post a system notification for an observable conversation
+ // because we already show an angry red annotation in the conversation
+ // itself or in the conversation preview snippet.
+ continue;
+ }
+
+ cursorPosition = messageDataCursor.getPosition();
+ failedMessages.add(cursorPosition);
+ conversationsWithFailedMessages.add(conversationId);
+ }
+
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "Found " + failedMessages.size() + " failed messages");
+ }
+ if (failedMessages.size() > 0) {
+ final NotificationCompat.Builder builder =
+ new NotificationCompat.Builder(context);
+
+ CharSequence line1;
+ CharSequence line2;
+ final boolean isRichContent = false;
+ ConversationIdSet conversationIds = null;
+ PendingIntent destinationIntent;
+ if (failedMessages.size() == 1) {
+ messageDataCursor.moveToPosition(cursorPosition);
+ messageData.bind(messageDataCursor);
+ final String conversationId = messageData.getConversationId();
+
+ // We have a single conversation, go directly to that conversation.
+ destinationIntent = UIIntents.get()
+ .getPendingIntentForConversationActivity(context,
+ conversationId,
+ null /*draft*/);
+
+ conversationIds = ConversationIdSet.createSet(conversationId);
+
+ final String failedMessgeSnippet = messageData.getMessageText();
+ int failureStringId;
+ if (messageData.getStatus() ==
+ MessageData.BUGLE_STATUS_INCOMING_DOWNLOAD_FAILED) {
+ failureStringId =
+ R.string.notification_download_failures_line1_singular;
+ } else {
+ failureStringId = R.string.notification_send_failures_line1_singular;
+ }
+ line1 = resources.getString(failureStringId);
+ line2 = failedMessgeSnippet;
+ // Set rich text for non-SMS messages or MMS push notification messages
+ // which we generate locally with rich text
+ // TODO- fix this
+// if (messageData.isMmsInd()) {
+// isRichContent = true;
+// }
+ } else {
+ // We have notifications for multiple conversation, go to the conversation
+ // list.
+ destinationIntent = UIIntents.get()
+ .getPendingIntentForConversationListActivity(context);
+
+ int line1StringId;
+ int line2PluralsId;
+ if (messageData.getStatus() ==
+ MessageData.BUGLE_STATUS_INCOMING_DOWNLOAD_FAILED) {
+ line1StringId =
+ R.string.notification_download_failures_line1_plural;
+ line2PluralsId = R.plurals.notification_download_failures;
+ } else {
+ line1StringId = R.string.notification_send_failures_line1_plural;
+ line2PluralsId = R.plurals.notification_send_failures;
+ }
+ line1 = resources.getString(line1StringId);
+ line2 = resources.getQuantityString(
+ line2PluralsId,
+ conversationsWithFailedMessages.size(),
+ failedMessages.size(),
+ conversationsWithFailedMessages.size());
+ }
+ line1 = applyWarningTextColor(context, line1);
+ line2 = applyWarningTextColor(context, line2);
+
+ final PendingIntent pendingIntentForDelete =
+ UIIntents.get().getPendingIntentForClearingNotifications(
+ context,
+ BugleNotifications.UPDATE_ERRORS,
+ conversationIds,
+ 0);
+
+ builder
+ .setContentTitle(line1)
+ .setTicker(line1)
+ .setWhen(when > 0 ? when : System.currentTimeMillis())
+ .setSmallIcon(R.drawable.ic_failed_light)
+ .setDeleteIntent(pendingIntentForDelete)
+ .setContentIntent(destinationIntent)
+ .setSound(UriUtil.getUriForResourceId(context, R.raw.message_failure));
+ if (isRichContent && !TextUtils.isEmpty(line2)) {
+ final NotificationCompat.InboxStyle inboxStyle =
+ new NotificationCompat.InboxStyle(builder);
+ if (line2 != null) {
+ inboxStyle.addLine(Html.fromHtml(line2.toString()));
+ }
+ builder.setStyle(inboxStyle);
+ } else {
+ builder.setContentText(line2);
+ }
+
+ if (builder != null) {
+ notificationManager.notify(
+ BugleNotifications.buildNotificationTag(
+ PendingIntentConstants.MSG_SEND_ERROR, null),
+ PendingIntentConstants.MSG_SEND_ERROR,
+ builder.build());
+ }
+ } else {
+ notificationManager.cancel(
+ BugleNotifications.buildNotificationTag(
+ PendingIntentConstants.MSG_SEND_ERROR, null),
+ PendingIntentConstants.MSG_SEND_ERROR);
+ }
+ }
+ } finally {
+ if (messageDataCursor != null) {
+ messageDataCursor.close();
+ }
+ }
+ }
+}
diff --git a/src/com/android/messaging/datamodel/MessageTextStats.java b/src/com/android/messaging/datamodel/MessageTextStats.java
new file mode 100644
index 0000000..2bd24ff
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MessageTextStats.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.telephony.SmsMessage;
+
+import com.android.messaging.sms.MmsConfig;
+
+public class MessageTextStats {
+ private boolean mMessageLengthRequiresMms;
+ private int mMessageCount;
+ private int mCodePointsRemainingInCurrentMessage;
+
+ public MessageTextStats() {
+ mCodePointsRemainingInCurrentMessage = Integer.MAX_VALUE;
+ }
+
+ public int getNumMessagesToBeSent() {
+ return mMessageCount;
+ }
+
+ public int getCodePointsRemainingInCurrentMessage() {
+ return mCodePointsRemainingInCurrentMessage;
+ }
+
+ public boolean getMessageLengthRequiresMms() {
+ return mMessageLengthRequiresMms;
+ }
+
+ public void updateMessageTextStats(final int selfSubId, final String messageText) {
+ final int[] params = SmsMessage.calculateLength(messageText, false);
+ /* SmsMessage.calculateLength returns an int[4] with:
+ * int[0] being the number of SMS's required,
+ * int[1] the number of code points used,
+ * int[2] is the number of code points remaining until the next message.
+ * int[3] is the encoding type that should be used for the message.
+ */
+ mMessageCount = params[0];
+ mCodePointsRemainingInCurrentMessage = params[2];
+
+ final MmsConfig mmsConfig = MmsConfig.get(selfSubId);
+ if (!mmsConfig.getMultipartSmsEnabled() &&
+ !mmsConfig.getSendMultipartSmsAsSeparateMessages()) {
+ // The provider doesn't support multi-part sms's and we should use MMS to
+ // send multi-part sms, so as soon as the user types
+ // an sms longer than one segment, we have to turn the message into an mms.
+ mMessageLengthRequiresMms = mMessageCount > 1;
+ } else {
+ final int threshold = mmsConfig.getSmsToMmsTextThreshold();
+ mMessageLengthRequiresMms = threshold > 0 && mMessageCount > threshold;
+ }
+ // Some carriers require any SMS message longer than 80 to be sent as MMS
+ // see b/12122333
+ int smsToMmsLengthThreshold = mmsConfig.getSmsToMmsTextLengthThreshold();
+ if (smsToMmsLengthThreshold > 0) {
+ final int usedInCurrentMessage = params[1];
+ /*
+ * A little hacky way to find out if we should count characters in double bytes.
+ * SmsMessage.calculateLength counts message code units based on the characters
+ * in input. If all of them are ascii, the max length is
+ * SmsMessage.MAX_USER_DATA_SEPTETS (160). If any of them are double-byte, like
+ * Korean or Chinese, the max length is SmsMessage.MAX_USER_DATA_BYTES (140) bytes
+ * (70 code units).
+ * Here we check if the total code units we can use is smaller than 140. If so,
+ * we know we should count threshold in double-byte, so divide the threshold by 2.
+ * In this way, we will count Korean text correctly with regard to the length threshold.
+ */
+ if (usedInCurrentMessage + mCodePointsRemainingInCurrentMessage
+ < SmsMessage.MAX_USER_DATA_BYTES) {
+ smsToMmsLengthThreshold /= 2;
+ }
+ if (usedInCurrentMessage > smsToMmsLengthThreshold) {
+ mMessageLengthRequiresMms = true;
+ }
+ }
+ }
+
+}
diff --git a/src/com/android/messaging/datamodel/MessagingContentProvider.java b/src/com/android/messaging/datamodel/MessagingContentProvider.java
new file mode 100644
index 0000000..7688abd
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MessagingContentProvider.java
@@ -0,0 +1,476 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+
+import com.android.messaging.BugleApplication;
+import com.android.messaging.Factory;
+import com.android.messaging.datamodel.DatabaseHelper.ConversationColumns;
+import com.android.messaging.datamodel.DatabaseHelper.ConversationParticipantsColumns;
+import com.android.messaging.datamodel.DatabaseHelper.ParticipantColumns;
+import com.android.messaging.datamodel.data.ConversationListItemData;
+import com.android.messaging.datamodel.data.ConversationMessageData;
+import com.android.messaging.datamodel.data.MessageData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.PhoneUtils;
+import com.android.messaging.widget.BugleWidgetProvider;
+import com.android.messaging.widget.WidgetConversationProvider;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.io.FileDescriptor;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+
+/**
+ * A centralized provider for Uris exposed by Bugle.
+ * */
+public class MessagingContentProvider extends ContentProvider {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ @VisibleForTesting
+ public static final String AUTHORITY =
+ "com.android.messaging.datamodel.MessagingContentProvider";
+ private static final String CONTENT_AUTHORITY = "content://" + AUTHORITY + '/';
+
+ // Conversations query
+ private static final String CONVERSATIONS_QUERY = "conversations";
+
+ public static final Uri CONVERSATIONS_URI = Uri.parse(CONTENT_AUTHORITY + CONVERSATIONS_QUERY);
+ static final Uri PARTS_URI = Uri.parse(CONTENT_AUTHORITY + DatabaseHelper.PARTS_TABLE);
+
+ // Messages query
+ private static final String MESSAGES_QUERY = "messages";
+
+ static final Uri MESSAGES_URI = Uri.parse(CONTENT_AUTHORITY + MESSAGES_QUERY);
+
+ public static final Uri CONVERSATION_MESSAGES_URI = Uri.parse(CONTENT_AUTHORITY +
+ MESSAGES_QUERY + "/conversation");
+
+ // Conversation participants query
+ private static final String PARTICIPANTS_QUERY = "participants";
+
+ static class ConversationParticipantsQueryColumns extends ParticipantColumns {
+ static final String CONVERSATION_ID = ConversationParticipantsColumns.CONVERSATION_ID;
+ }
+
+ static final Uri CONVERSATION_PARTICIPANTS_URI = Uri.parse(CONTENT_AUTHORITY +
+ PARTICIPANTS_QUERY + "/conversation");
+
+ public static final Uri PARTICIPANTS_URI = Uri.parse(CONTENT_AUTHORITY + PARTICIPANTS_QUERY);
+
+ // Conversation images query
+ private static final String CONVERSATION_IMAGES_QUERY = "conversation_images";
+
+ public static final Uri CONVERSATION_IMAGES_URI = Uri.parse(CONTENT_AUTHORITY +
+ CONVERSATION_IMAGES_QUERY);
+
+ private static final String DRAFT_IMAGES_QUERY = "draft_images";
+
+ public static final Uri DRAFT_IMAGES_URI = Uri.parse(CONTENT_AUTHORITY +
+ DRAFT_IMAGES_QUERY);
+
+ /**
+ * Notifies that all data exposed by the provider needs to be refreshed.
+ *
+ * IMPORTANT! You probably shouldn't be calling this. Prefer to notify more specific
+ * uri's instead. Currently only sync uses this, because sync can potentially update many
+ * different tables at once.
+ */
+ public static void notifyEverythingChanged() {
+ final Uri uri = Uri.parse(CONTENT_AUTHORITY);
+ final Context context = Factory.get().getApplicationContext();
+ final ContentResolver cr = context.getContentResolver();
+ cr.notifyChange(uri, null);
+
+ // Notify any conversations widgets the conversation list has changed.
+ BugleWidgetProvider.notifyConversationListChanged(context);
+
+ // Notify all conversation widgets to update.
+ WidgetConversationProvider.notifyMessagesChanged(context, null /*conversationId*/);
+ }
+
+ /**
+ * Build a participant uri from the conversation id.
+ */
+ public static Uri buildConversationParticipantsUri(final String conversationId) {
+ final Uri.Builder builder = CONVERSATION_PARTICIPANTS_URI.buildUpon();
+ builder.appendPath(conversationId);
+ return builder.build();
+ }
+
+ public static void notifyParticipantsChanged(final String conversationId) {
+ final Uri uri = buildConversationParticipantsUri(conversationId);
+ final ContentResolver cr = Factory.get().getApplicationContext().getContentResolver();
+ cr.notifyChange(uri, null);
+ }
+
+ public static void notifyAllMessagesChanged() {
+ final ContentResolver cr = Factory.get().getApplicationContext().getContentResolver();
+ cr.notifyChange(CONVERSATION_MESSAGES_URI, null);
+ }
+
+ public static void notifyAllParticipantsChanged() {
+ final ContentResolver cr = Factory.get().getApplicationContext().getContentResolver();
+ cr.notifyChange(CONVERSATION_PARTICIPANTS_URI, null);
+ }
+
+ // Default value for unknown dimension of image
+ public static final int UNSPECIFIED_SIZE = -1;
+
+ // Internal
+ private static final int CONVERSATIONS_QUERY_CODE = 10;
+
+ private static final int CONVERSATION_QUERY_CODE = 20;
+ private static final int CONVERSATION_MESSAGES_QUERY_CODE = 30;
+ private static final int CONVERSATION_PARTICIPANTS_QUERY_CODE = 40;
+ private static final int CONVERSATION_IMAGES_QUERY_CODE = 50;
+ private static final int DRAFT_IMAGES_QUERY_CODE = 60;
+ private static final int PARTICIPANTS_QUERY_CODE = 70;
+
+ // TODO: Move to a better structured URI namespace.
+ private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+ static {
+ sURIMatcher.addURI(AUTHORITY, CONVERSATIONS_QUERY, CONVERSATIONS_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, CONVERSATIONS_QUERY + "/*", CONVERSATION_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, MESSAGES_QUERY + "/conversation/*",
+ CONVERSATION_MESSAGES_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, PARTICIPANTS_QUERY + "/conversation/*",
+ CONVERSATION_PARTICIPANTS_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, PARTICIPANTS_QUERY, PARTICIPANTS_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, CONVERSATION_IMAGES_QUERY + "/*",
+ CONVERSATION_IMAGES_QUERY_CODE);
+ sURIMatcher.addURI(AUTHORITY, DRAFT_IMAGES_QUERY + "/*",
+ DRAFT_IMAGES_QUERY_CODE);
+ }
+
+ /**
+ * Build a messages uri from the conversation id.
+ */
+ public static Uri buildConversationMessagesUri(final String conversationId) {
+ final Uri.Builder builder = CONVERSATION_MESSAGES_URI.buildUpon();
+ builder.appendPath(conversationId);
+ return builder.build();
+ }
+
+ public static void notifyMessagesChanged(final String conversationId) {
+ final Uri uri = buildConversationMessagesUri(conversationId);
+ final Context context = Factory.get().getApplicationContext();
+ final ContentResolver cr = context.getContentResolver();
+ cr.notifyChange(uri, null);
+ notifyConversationListChanged();
+
+ // Notify the widget the messages changed
+ WidgetConversationProvider.notifyMessagesChanged(context, conversationId);
+ }
+
+ /**
+ * Build a conversation metadata uri from a conversation id.
+ */
+ public static Uri buildConversationMetadataUri(final String conversationId) {
+ final Uri.Builder builder = CONVERSATIONS_URI.buildUpon();
+ builder.appendPath(conversationId);
+ return builder.build();
+ }
+
+ public static void notifyConversationMetadataChanged(final String conversationId) {
+ final Uri uri = buildConversationMetadataUri(conversationId);
+ final ContentResolver cr = Factory.get().getApplicationContext().getContentResolver();
+ cr.notifyChange(uri, null);
+ notifyConversationListChanged();
+ }
+
+ public static void notifyPartsChanged() {
+ final ContentResolver cr = Factory.get().getApplicationContext().getContentResolver();
+ cr.notifyChange(PARTS_URI, null);
+ }
+
+ public static void notifyConversationListChanged() {
+ final Context context = Factory.get().getApplicationContext();
+ final ContentResolver cr = context.getContentResolver();
+ cr.notifyChange(CONVERSATIONS_URI, null);
+
+ // Notify the widget the conversation list changed
+ BugleWidgetProvider.notifyConversationListChanged(context);
+ }
+
+ /**
+ * Build a conversation images uri from a conversation id.
+ */
+ public static Uri buildConversationImagesUri(final String conversationId) {
+ final Uri.Builder builder = CONVERSATION_IMAGES_URI.buildUpon();
+ builder.appendPath(conversationId);
+ return builder.build();
+ }
+
+ /**
+ * Build a draft images uri from a conversation id.
+ */
+ public static Uri buildDraftImagesUri(final String conversationId) {
+ final Uri.Builder builder = DRAFT_IMAGES_URI.buildUpon();
+ builder.appendPath(conversationId);
+ return builder.build();
+ }
+
+ private DatabaseHelper mDatabaseHelper;
+ private DatabaseWrapper mDatabaseWrapper;
+
+ public MessagingContentProvider() {
+ super();
+ }
+
+ @VisibleForTesting
+ public void setDatabaseForTest(final DatabaseWrapper db) {
+ Assert.isTrue(BugleApplication.isRunningTests());
+ mDatabaseWrapper = db;
+ }
+
+ private DatabaseWrapper getDatabaseWrapper() {
+ if (mDatabaseWrapper == null) {
+ mDatabaseWrapper = mDatabaseHelper.getDatabase();
+ }
+ return mDatabaseWrapper;
+ }
+
+ @Override
+ public Cursor query(final Uri uri, final String[] projection, String selection,
+ final String[] selectionArgs, String sortOrder) {
+
+ // Processes other than self are allowed to temporarily access the media
+ // scratch space; we grant uri read access on a case-by-case basis. Dialer app and
+ // contacts app would doQuery() on the vCard uri before trying to open the inputStream.
+ // There's nothing that we need to return for this uri so just No-Op.
+ //if (isMediaScratchSpaceUri(uri)) {
+ // return null;
+ //}
+
+ final SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
+
+ String[] queryArgs = selectionArgs;
+ final int match = sURIMatcher.match(uri);
+ String groupBy = null;
+ String limit = null;
+ switch (match) {
+ case CONVERSATIONS_QUERY_CODE:
+ queryBuilder.setTables(ConversationListItemData.getConversationListView());
+ // Hide empty conversations (ones with 0 sort_timestamp)
+ queryBuilder.appendWhere(ConversationColumns.SORT_TIMESTAMP + " > 0 ");
+ break;
+ case CONVERSATION_QUERY_CODE:
+ queryBuilder.setTables(ConversationListItemData.getConversationListView());
+ if (uri.getPathSegments().size() == 2) {
+ queryBuilder.appendWhere(ConversationColumns._ID + "=?");
+ // Get the conversation id from the uri
+ queryArgs = prependArgs(queryArgs, uri.getPathSegments().get(1));
+ } else {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ break;
+ case CONVERSATION_PARTICIPANTS_QUERY_CODE:
+ queryBuilder.setTables(DatabaseHelper.PARTICIPANTS_TABLE);
+ if (uri.getPathSegments().size() == 3 &&
+ TextUtils.equals(uri.getPathSegments().get(1), "conversation")) {
+ queryBuilder.appendWhere(ParticipantColumns._ID + " IN ( " + "SELECT "
+ + ConversationParticipantsColumns.PARTICIPANT_ID + " AS "
+ + ParticipantColumns._ID
+ + " FROM " + DatabaseHelper.CONVERSATION_PARTICIPANTS_TABLE
+ + " WHERE " + ConversationParticipantsColumns.CONVERSATION_ID
+ + " =? UNION SELECT " + ParticipantColumns._ID + " FROM "
+ + DatabaseHelper.PARTICIPANTS_TABLE + " WHERE "
+ + ParticipantColumns.SUB_ID + " != "
+ + ParticipantData.OTHER_THAN_SELF_SUB_ID + " )");
+ // Get the conversation id from the uri
+ queryArgs = prependArgs(queryArgs, uri.getPathSegments().get(2));
+ } else {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ break;
+ case PARTICIPANTS_QUERY_CODE:
+ queryBuilder.setTables(DatabaseHelper.PARTICIPANTS_TABLE);
+ if (uri.getPathSegments().size() != 1) {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ break;
+ case CONVERSATION_MESSAGES_QUERY_CODE:
+ if (uri.getPathSegments().size() == 3 &&
+ TextUtils.equals(uri.getPathSegments().get(1), "conversation")) {
+ // Get the conversation id from the uri
+ final String conversationId = uri.getPathSegments().get(2);
+
+ // We need to handle this query differently, instead of falling through to the
+ // generic query call at the bottom. For performance reasons, the conversation
+ // messages query is executed as a raw query. It is invalid to specify
+ // selection/sorting for this query.
+
+ if (selection == null && selectionArgs == null && sortOrder == null) {
+ return queryConversationMessages(conversationId, uri);
+ } else {
+ throw new IllegalArgumentException(
+ "Cannot set selection or sort order with this query");
+ }
+ } else {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ case CONVERSATION_IMAGES_QUERY_CODE:
+ queryBuilder.setTables(ConversationImagePartsView.getViewName());
+ if (uri.getPathSegments().size() == 2) {
+ // Exclude draft.
+ queryBuilder.appendWhere(
+ ConversationImagePartsView.Columns.CONVERSATION_ID + " =? AND " +
+ ConversationImagePartsView.Columns.STATUS + "<>" +
+ MessageData.BUGLE_STATUS_OUTGOING_DRAFT);
+ // Get the conversation id from the uri
+ queryArgs = prependArgs(queryArgs, uri.getPathSegments().get(1));
+ } else {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ break;
+ case DRAFT_IMAGES_QUERY_CODE:
+ queryBuilder.setTables(ConversationImagePartsView.getViewName());
+ if (uri.getPathSegments().size() == 2) {
+ // Draft only.
+ queryBuilder.appendWhere(
+ ConversationImagePartsView.Columns.CONVERSATION_ID + " =? AND " +
+ ConversationImagePartsView.Columns.STATUS + "=" +
+ MessageData.BUGLE_STATUS_OUTGOING_DRAFT);
+ // Get the conversation id from the uri
+ queryArgs = prependArgs(queryArgs, uri.getPathSegments().get(1));
+ } else {
+ throw new IllegalArgumentException("Malformed URI " + uri);
+ }
+ break;
+ default: {
+ throw new IllegalArgumentException("Unknown URI " + uri);
+ }
+ }
+
+ final Cursor cursor = getDatabaseWrapper().query(queryBuilder, projection, selection,
+ queryArgs, groupBy, null, sortOrder, limit);
+ cursor.setNotificationUri(getContext().getContentResolver(), uri);
+ return cursor;
+ }
+
+ private Cursor queryConversationMessages(final String conversationId, final Uri notifyUri) {
+ final String[] queryArgs = { conversationId };
+ final Cursor cursor = getDatabaseWrapper().rawQuery(
+ ConversationMessageData.getConversationMessagesQuerySql(), queryArgs);
+ cursor.setNotificationUri(getContext().getContentResolver(), notifyUri);
+ return cursor;
+ }
+
+ @Override
+ public String getType(final Uri uri) {
+ final StringBuilder sb = new
+ StringBuilder("vnd.android.cursor.dir/vnd.android.messaging.");
+
+ switch (sURIMatcher.match(uri)) {
+ case CONVERSATIONS_QUERY_CODE: {
+ sb.append(CONVERSATIONS_QUERY);
+ break;
+ }
+ default: {
+ throw new IllegalArgumentException("Unknown URI: " + uri);
+ }
+ }
+ return sb.toString();
+ }
+
+ protected DatabaseHelper getDatabase() {
+ return DatabaseHelper.getInstance(getContext());
+ }
+
+ @Override
+ public ParcelFileDescriptor openFile(final Uri uri, final String fileMode)
+ throws FileNotFoundException {
+ throw new IllegalArgumentException("openFile not supported: " + uri);
+ }
+
+ @Override
+ public Uri insert(final Uri uri, final ContentValues values) {
+ throw new IllegalStateException("Insert not supported " + uri);
+ }
+
+ @Override
+ public int delete(final Uri uri, final String selection, final String[] selectionArgs) {
+ throw new IllegalArgumentException("Delete not supported: " + uri);
+ }
+
+ @Override
+ public int update(final Uri uri, final ContentValues values, final String selection,
+ final String[] selectionArgs) {
+ throw new IllegalArgumentException("Update not supported: " + uri);
+ }
+
+ /**
+ * Prepends new arguments to the existing argument list.
+ *
+ * @param oldArgList The current list of arguments. May be {@code null}
+ * @param args The new arguments to prepend
+ * @return A new argument list with the given arguments prepended
+ */
+ private String[] prependArgs(final String[] oldArgList, final String... args) {
+ if (args == null || args.length == 0) {
+ return oldArgList;
+ }
+ final int oldArgCount = (oldArgList == null ? 0 : oldArgList.length);
+ final int newArgCount = args.length;
+
+ final String[] newArgs = new String[oldArgCount + newArgCount];
+ System.arraycopy(args, 0, newArgs, 0, newArgCount);
+ if (oldArgCount > 0) {
+ System.arraycopy(oldArgList, 0, newArgs, newArgCount, oldArgCount);
+ }
+ return newArgs;
+ }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void dump(final FileDescriptor fd, final PrintWriter writer, final String[] args) {
+ // First dump out the default SMS app package name
+ String defaultSmsApp = PhoneUtils.getDefault().getDefaultSmsApp();
+ if (TextUtils.isEmpty(defaultSmsApp)) {
+ if (OsUtil.isAtLeastKLP()) {
+ defaultSmsApp = "None";
+ } else {
+ defaultSmsApp = "None (pre-Kitkat)";
+ }
+ }
+ writer.println("Default SMS app: " + defaultSmsApp);
+ // Now dump logs
+ LogUtil.dump(writer);
+ }
+
+ @Override
+ public boolean onCreate() {
+ // This is going to wind up calling into createDatabase() below.
+ mDatabaseHelper = (DatabaseHelper) getDatabase();
+ // We cannot initialize mDatabaseWrapper yet as the Factory may not be initialized
+ return true;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/MmsFileProvider.java b/src/com/android/messaging/datamodel/MmsFileProvider.java
new file mode 100644
index 0000000..0022630
--- /dev/null
+++ b/src/com/android/messaging/datamodel/MmsFileProvider.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.net.Uri;
+
+import com.android.messaging.Factory;
+import com.android.messaging.util.LogUtil;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.io.File;
+
+/**
+ * A very simple content provider that can serve mms files from our cache directory.
+ */
+public class MmsFileProvider extends FileProvider {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ @VisibleForTesting
+ static final String AUTHORITY = "com.android.messaging.datamodel.MmsFileProvider";
+ private static final String RAW_MMS_DIR = "rawmms";
+
+ /**
+ * Returns a uri that can be used to access a raw mms file.
+ *
+ * @return the URI for an raw mms file
+ */
+ public static Uri buildRawMmsUri() {
+ final Uri uri = FileProvider.buildFileUri(AUTHORITY, null);
+ final File file = getFile(uri.getPath());
+ if (!ensureFileExists(file)) {
+ LogUtil.e(TAG, "Failed to create temp file " + file.getAbsolutePath());
+ }
+ return uri;
+ }
+
+ @Override
+ File getFile(final String path, final String extension) {
+ return getFile(path);
+ }
+
+ public static File getFile(final Uri uri) {
+ return getFile(uri.getPath());
+ }
+
+ private static File getFile(final String path) {
+ final Context context = Factory.get().getApplicationContext();
+ return new File(getDirectory(context), path + ".dat");
+ }
+
+ private static File getDirectory(final Context context) {
+ return new File(context.getCacheDir(), RAW_MMS_DIR);
+ }
+}
diff --git a/src/com/android/messaging/datamodel/NoConfirmationSmsSendService.java b/src/com/android/messaging/datamodel/NoConfirmationSmsSendService.java
new file mode 100644
index 0000000..791ff34
--- /dev/null
+++ b/src/com/android/messaging/datamodel/NoConfirmationSmsSendService.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.app.IntentService;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.RemoteInput;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+
+import com.android.messaging.datamodel.action.InsertNewMessageAction;
+import com.android.messaging.datamodel.action.UpdateMessageNotificationAction;
+import com.android.messaging.datamodel.data.MessageData;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.sms.MmsUtils;
+import com.android.messaging.ui.UIIntents;
+import com.android.messaging.ui.conversationlist.ConversationListActivity;
+import com.android.messaging.util.LogUtil;
+
+/**
+ * Respond to a special intent and send an SMS message without the user's intervention, unless
+ * the intent extra "showUI" is true.
+ */
+public class NoConfirmationSmsSendService extends IntentService {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ private static final String EXTRA_SUBSCRIPTION = "subscription";
+ public static final String EXTRA_SELF_ID = "self_id";
+
+ public NoConfirmationSmsSendService() {
+ // Class name will be the thread name.
+ super(NoConfirmationSmsSendService.class.getName());
+
+ // Intent should be redelivered if the process gets killed before completing the job.
+ setIntentRedelivery(true);
+ }
+
+ @Override
+ protected void onHandleIntent(final Intent intent) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "NoConfirmationSmsSendService onHandleIntent");
+ }
+
+ final String action = intent.getAction();
+ if (!TelephonyManager.ACTION_RESPOND_VIA_MESSAGE.equals(action)) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "NoConfirmationSmsSendService onHandleIntent wrong action: " +
+ action);
+ }
+ return;
+ }
+ final Bundle extras = intent.getExtras();
+ if (extras == null) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Called to send SMS but no extras");
+ }
+ return;
+ }
+
+ // Get all possible extras from intent
+ final String conversationId =
+ intent.getStringExtra(UIIntents.UI_INTENT_EXTRA_CONVERSATION_ID);
+ final String selfId = intent.getStringExtra(EXTRA_SELF_ID);
+ final boolean requiresMms = intent.getBooleanExtra(UIIntents.UI_INTENT_EXTRA_REQUIRES_MMS,
+ false);
+ final String message = getText(intent, Intent.EXTRA_TEXT);
+ final String subject = getText(intent, Intent.EXTRA_SUBJECT);
+ final int subId = extras.getInt(EXTRA_SUBSCRIPTION, ParticipantData.DEFAULT_SELF_SUB_ID);
+
+ final Uri intentUri = intent.getData();
+ final String recipients = intentUri != null ? MmsUtils.getSmsRecipients(intentUri) : null;
+
+ if (TextUtils.isEmpty(recipients) && TextUtils.isEmpty(conversationId)) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Both conversationId and recipient(s) cannot be empty");
+ }
+ return;
+ }
+
+ if (extras.getBoolean("showUI", false)) {
+ startActivity(new Intent(this, ConversationListActivity.class));
+ } else {
+ if (TextUtils.isEmpty(message)) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Message cannot be empty");
+ }
+ return;
+ }
+
+ // TODO: it's possible that a long message would require sending it via mms,
+ // but we're not testing for that here and we're sending the message as an sms.
+
+ if (TextUtils.isEmpty(conversationId)) {
+ InsertNewMessageAction.insertNewMessage(subId, recipients, message, subject);
+ } else {
+ MessageData messageData = null;
+ if (requiresMms) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Auto-sending MMS message in conversation: " +
+ conversationId);
+ }
+ messageData = MessageData.createDraftMmsMessage(conversationId, selfId, message,
+ subject);
+ } else {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Auto-sending SMS message in conversation: " +
+ conversationId);
+ }
+ messageData = MessageData.createDraftSmsMessage(conversationId, selfId,
+ message);
+ }
+ InsertNewMessageAction.insertNewMessage(messageData);
+ }
+ UpdateMessageNotificationAction.updateMessageNotification();
+ }
+ }
+
+ private String getText(final Intent intent, final String textType) {
+ final String message = intent.getStringExtra(textType);
+ if (message == null) {
+ final Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
+ if (remoteInput != null) {
+ final CharSequence extra = remoteInput.getCharSequence(textType);
+ if (extra != null) {
+ return extra.toString();
+ }
+ }
+ }
+ return message;
+ }
+
+}
diff --git a/src/com/android/messaging/datamodel/NotificationState.java b/src/com/android/messaging/datamodel/NotificationState.java
new file mode 100644
index 0000000..d589874
--- /dev/null
+++ b/src/com/android/messaging/datamodel/NotificationState.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.messaging.datamodel;
+
+import android.app.PendingIntent;
+import android.net.Uri;
+import android.support.v4.app.NotificationCompat;
+
+import com.android.messaging.datamodel.DatabaseHelper.MessageColumns;
+import com.android.messaging.datamodel.data.MessageData;
+import com.android.messaging.util.ConversationIdSet;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+/**
+ * Base class for representing notifications. The main reason for this class is that in order to
+ * show pictures or avatars they might need to be loaded in the background. This class and
+ * subclasses can do the main work to get the notification ready and then wait until any images
+ * that are needed are ready before posting.
+ *
+ * The creation of a notification is split into two parts. The NotificationState ctor should
+ * setup the basic information including the mContentIntent. A Notification Builder is created in
+ * RealTimeChatNotifications and passed to the build() method of each notification where the
+ * Notification is fully specified.
+ *
+ * TODO: There is still some duplication and inconsistency in the utility functions and
+ * placement of different building blocks across notification types (e.g. summary text for accounts)
+ */
+public abstract class NotificationState {
+ private static final int CONTENT_INTENT_REQUEST_CODE_OFFSET = 0;
+ private static final int CLEAR_INTENT_REQUEST_CODE_OFFSET = 1;
+ private static final int NUM_REQUEST_CODES_NEEDED = 2;
+
+ public interface FailedMessageQuery {
+ static final String FAILED_MESSAGES_WHERE_CLAUSE =
+ "((" + MessageColumns.STATUS + " = " +
+ MessageData.BUGLE_STATUS_OUTGOING_FAILED + " OR " +
+ MessageColumns.STATUS + " = " +
+ MessageData.BUGLE_STATUS_INCOMING_DOWNLOAD_FAILED + ") AND " +
+ DatabaseHelper.MessageColumns.SEEN + " = 0)";
+
+ static final String FAILED_ORDER_BY = DatabaseHelper.MessageColumns.CONVERSATION_ID + ", " +
+ DatabaseHelper.MessageColumns.SENT_TIMESTAMP + " asc";
+ }
+
+ public final ConversationIdSet mConversationIds;
+ public final HashSet mPeople;
+
+ public NotificationCompat.Style mNotificationStyle;
+ public NotificationCompat.Builder mNotificationBuilder;
+ public boolean mCanceled;
+ public int mType;
+ public int mBaseRequestCode;
+ public ArrayList mParticipantAvatarsUris = null;
+ public ArrayList mParticipantContactUris = null;
+
+ NotificationState(final ConversationIdSet conversationIds) {
+ mConversationIds = conversationIds;
+ mPeople = new HashSet();
+ }
+
+ /**
+ * The intent to be triggered when the notification is dismissed.
+ */
+ public abstract PendingIntent getClearIntent();
+
+ protected Uri getAttachmentUri() {
+ return null;
+ }
+
+ // Returns the mime type of the attachment (See ContentType class for definitions)
+ protected String getAttachmentType() {
+ return null;
+ }
+
+ /**
+ * Build the notification using the given builder.
+ * @param builder
+ * @return The style of the notification.
+ */
+ protected abstract NotificationCompat.Style build(NotificationCompat.Builder builder);
+
+ protected void setAvatarUrlsForConversation(final String conversationId) {
+ }
+
+ protected void setPeopleForConversation(final String conversationId) {
+ }
+
+ /**
+ * Reserves request codes for this notification type. By default 2 codes are reserved, one for
+ * the main intent and another for the cancel intent. Override this function to reserve more.
+ */
+ public int getNumRequestCodesNeeded() {
+ return NUM_REQUEST_CODES_NEEDED;
+ }
+
+ public int getContentIntentRequestCode() {
+ return mBaseRequestCode + CONTENT_INTENT_REQUEST_CODE_OFFSET;
+ }
+
+ public int getClearIntentRequestCode() {
+ return mBaseRequestCode + CLEAR_INTENT_REQUEST_CODE_OFFSET;
+ }
+
+ /**
+ * Gets the appropriate icon needed for notifications.
+ */
+ public abstract int getIcon();
+
+ /**
+ * @return the type of notification that should be used from {@link RealTimeChatNotifications}
+ * so that the proper ringtone and vibrate settings can be used.
+ */
+ public int getLatestMessageNotificationType() {
+ return BugleNotifications.LOCAL_SMS_NOTIFICATION;
+ }
+
+ /**
+ * @return the notification priority level for this notification.
+ */
+ public abstract int getPriority();
+
+ /** @return custom ringtone URI or null if not set */
+ public String getRingtoneUri() {
+ return null;
+ }
+
+ public boolean getNotificationVibrate() {
+ return false;
+ }
+
+ public long getLatestReceivedTimestamp() {
+ return Long.MIN_VALUE;
+ }
+}
diff --git a/src/com/android/messaging/datamodel/ParticipantRefresh.java b/src/com/android/messaging/datamodel/ParticipantRefresh.java
new file mode 100644
index 0000000..5324496
--- /dev/null
+++ b/src/com/android/messaging/datamodel/ParticipantRefresh.java
@@ -0,0 +1,738 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.ContentValues;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.graphics.Color;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.support.v4.util.ArrayMap;
+import android.telephony.SubscriptionInfo;
+import android.text.TextUtils;
+
+import com.android.messaging.Factory;
+import com.android.messaging.datamodel.DatabaseHelper.ConversationColumns;
+import com.android.messaging.datamodel.DatabaseHelper.ConversationParticipantsColumns;
+import com.android.messaging.datamodel.DatabaseHelper.ParticipantColumns;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.datamodel.data.ParticipantData.ParticipantsQuery;
+import com.android.messaging.ui.UIIntents;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.ContactUtil;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.PhoneUtils;
+import com.android.messaging.util.SafeAsyncTask;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Utility class for refreshing participant information based on matching contact. This updates
+ * 1. name, photo_uri, matching contact_id of participants.
+ * 2. generated_name of conversations.
+ *
+ * There are two kinds of participant refreshes,
+ * 1. Full refresh, this is triggered at application start or activity resumes after contact
+ * change is detected.
+ * 2. Partial refresh, this is triggered when a participant is added to a conversation. This
+ * normally happens during SMS sync.
+ */
+@VisibleForTesting
+public class ParticipantRefresh {
+ private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG;
+
+ /**
+ * Refresh all participants including ones that were resolved before.
+ */
+ public static final int REFRESH_MODE_FULL = 0;
+
+ /**
+ * Refresh all unresolved participants.
+ */
+ public static final int REFRESH_MODE_INCREMENTAL = 1;
+
+ /**
+ * Force refresh all self participants.
+ */
+ public static final int REFRESH_MODE_SELF_ONLY = 2;
+
+ public static class ConversationParticipantsQuery {
+ public static final String[] PROJECTION = new String[] {
+ ConversationParticipantsColumns._ID,
+ ConversationParticipantsColumns.CONVERSATION_ID,
+ ConversationParticipantsColumns.PARTICIPANT_ID
+ };
+
+ public static final int INDEX_ID = 0;
+ public static final int INDEX_CONVERSATION_ID = 1;
+ public static final int INDEX_PARTICIPANT_ID = 2;
+ }
+
+ // Track whether observer is initialized or not.
+ private static volatile boolean sObserverInitialized = false;
+ private static final Object sLock = new Object();
+ private static final AtomicBoolean sFullRefreshScheduled = new AtomicBoolean(false);
+ private static final Runnable sFullRefreshRunnable = new Runnable() {
+ @Override
+ public void run() {
+ final boolean oldScheduled = sFullRefreshScheduled.getAndSet(false);
+ Assert.isTrue(oldScheduled);
+ refreshParticipants(REFRESH_MODE_FULL);
+ }
+ };
+ private static final Runnable sSelfOnlyRefreshRunnable = new Runnable() {
+ @Override
+ public void run() {
+ refreshParticipants(REFRESH_MODE_SELF_ONLY);
+ }
+ };
+
+ /**
+ * A customized content resolver to track contact changes.
+ */
+ public static class ContactContentObserver extends ContentObserver {
+ private volatile boolean mContactChanged = false;
+
+ public ContactContentObserver() {
+ super(null);
+ }
+
+ @Override
+ public void onChange(final boolean selfChange) {
+ super.onChange(selfChange);
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Contacts changed");
+ }
+ mContactChanged = true;
+ }
+
+ public boolean getContactChanged() {
+ return mContactChanged;
+ }
+
+ public void resetContactChanged() {
+ mContactChanged = false;
+ }
+
+ public void initialize() {
+ // TODO: Handle enterprise contacts post M once contacts provider supports it
+ Factory.get().getApplicationContext().getContentResolver().registerContentObserver(
+ Phone.CONTENT_URI, true, this);
+ mContactChanged = true; // Force a full refresh on initialization.
+ }
+ }
+
+ /**
+ * Refresh participants only if needed, i.e., application start or contact changed.
+ */
+ public static void refreshParticipantsIfNeeded() {
+ if (ParticipantRefresh.getNeedFullRefresh() &&
+ sFullRefreshScheduled.compareAndSet(false, true)) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Started full participant refresh");
+ }
+ SafeAsyncTask.executeOnThreadPool(sFullRefreshRunnable);
+ } else if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Skipped full participant refresh");
+ }
+ }
+
+ /**
+ * Refresh self participants on subscription or settings change.
+ */
+ public static void refreshSelfParticipants() {
+ SafeAsyncTask.executeOnThreadPool(sSelfOnlyRefreshRunnable);
+ }
+
+ private static boolean getNeedFullRefresh() {
+ final ContactContentObserver observer = Factory.get().getContactContentObserver();
+ if (observer == null) {
+ // If there is no observer (for unittest cases), we don't need to refresh participants.
+ return false;
+ }
+
+ if (!sObserverInitialized) {
+ synchronized (sLock) {
+ if (!sObserverInitialized) {
+ observer.initialize();
+ sObserverInitialized = true;
+ }
+ }
+ }
+
+ return observer.getContactChanged();
+ }
+
+ private static void resetNeedFullRefresh() {
+ final ContactContentObserver observer = Factory.get().getContactContentObserver();
+ if (observer != null) {
+ observer.resetContactChanged();
+ }
+ }
+
+ /**
+ * This class is totally static. Make constructor to be private so that an instance
+ * of this class would not be created by by mistake.
+ */
+ private ParticipantRefresh() {
+ }
+
+ /**
+ * Refresh participants in Bugle.
+ *
+ * @param refreshMode the refresh mode desired. See {@link #REFRESH_MODE_FULL},
+ * {@link #REFRESH_MODE_INCREMENTAL}, and {@link #REFRESH_MODE_SELF_ONLY}
+ */
+ @VisibleForTesting
+ static void refreshParticipants(final int refreshMode) {
+ Assert.inRange(refreshMode, REFRESH_MODE_FULL, REFRESH_MODE_SELF_ONLY);
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ switch (refreshMode) {
+ case REFRESH_MODE_FULL:
+ LogUtil.v(TAG, "Start full participant refresh");
+ break;
+ case REFRESH_MODE_INCREMENTAL:
+ LogUtil.v(TAG, "Start partial participant refresh");
+ break;
+ case REFRESH_MODE_SELF_ONLY:
+ LogUtil.v(TAG, "Start self participant refresh");
+ break;
+ }
+ }
+
+ if (!ContactUtil.hasReadContactsPermission() || !OsUtil.hasPhonePermission()) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Skipping participant referesh because of permissions");
+ }
+ return;
+ }
+
+ if (refreshMode == REFRESH_MODE_FULL) {
+ // resetNeedFullRefresh right away so that we will skip duplicated full refresh
+ // requests.
+ resetNeedFullRefresh();
+ }
+
+ if (refreshMode == REFRESH_MODE_FULL || refreshMode == REFRESH_MODE_SELF_ONLY) {
+ refreshSelfParticipantList();
+ }
+
+ final ArrayList changedParticipants = new ArrayList();
+
+ String selection = null;
+ String[] selectionArgs = null;
+
+ if (refreshMode == REFRESH_MODE_INCREMENTAL) {
+ // In case of incremental refresh, filter out participants that are already resolved.
+ selection = ParticipantColumns.CONTACT_ID + "=?";
+ selectionArgs = new String[] {
+ String.valueOf(ParticipantData.PARTICIPANT_CONTACT_ID_NOT_RESOLVED) };
+ } else if (refreshMode == REFRESH_MODE_SELF_ONLY) {
+ // In case of self-only refresh, filter out non-self participants.
+ selection = SELF_PARTICIPANTS_CLAUSE;
+ selectionArgs = null;
+ }
+
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ Cursor cursor = null;
+ boolean selfUpdated = false;
+ try {
+ cursor = db.query(DatabaseHelper.PARTICIPANTS_TABLE,
+ ParticipantsQuery.PROJECTION, selection, selectionArgs, null, null, null);
+
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ try {
+ final ParticipantData participantData =
+ ParticipantData.getFromCursor(cursor);
+ if (refreshParticipant(db, participantData)) {
+ if (participantData.isSelf()) {
+ selfUpdated = true;
+ }
+ updateParticipant(db, participantData);
+ final String id = participantData.getId();
+ changedParticipants.add(id);
+ }
+ } catch (final Exception exception) {
+ // Failure to update one participant shouldn't cancel the entire refresh.
+ // Log the failure so we know what's going on and resume the loop.
+ LogUtil.e(LogUtil.BUGLE_DATAMODEL_TAG, "ParticipantRefresh: Failed to " +
+ "update participant", exception);
+ }
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "Number of participants refreshed:" + changedParticipants.size());
+ }
+
+ // Refresh conversations for participants that are changed.
+ if (changedParticipants.size() > 0) {
+ BugleDatabaseOperations.refreshConversationsForParticipants(changedParticipants);
+ }
+ if (selfUpdated) {
+ // Boom
+ MessagingContentProvider.notifyAllParticipantsChanged();
+ MessagingContentProvider.notifyAllMessagesChanged();
+ }
+ }
+
+ private static final String SELF_PARTICIPANTS_CLAUSE = ParticipantColumns.SUB_ID
+ + " NOT IN ( "
+ + ParticipantData.OTHER_THAN_SELF_SUB_ID
+ + " )";
+
+ private static final Set getExistingSubIds() {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final HashSet existingSubIds = new HashSet();
+
+ Cursor cursor = null;
+ try {
+ cursor = db.query(DatabaseHelper.PARTICIPANTS_TABLE,
+ ParticipantsQuery.PROJECTION,
+ SELF_PARTICIPANTS_CLAUSE, null, null, null, null);
+
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ final int subId = cursor.getInt(ParticipantsQuery.INDEX_SUB_ID);
+ existingSubIds.add(subId);
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return existingSubIds;
+ }
+
+ private static final String UPDATE_SELF_PARTICIPANT_SUBSCRIPTION_SQL =
+ "UPDATE " + DatabaseHelper.PARTICIPANTS_TABLE + " SET "
+ + ParticipantColumns.SIM_SLOT_ID + " = %d, "
+ + ParticipantColumns.SUBSCRIPTION_COLOR + " = %d, "
+ + ParticipantColumns.SUBSCRIPTION_NAME + " = %s "
+ + " WHERE %s";
+
+ static String getUpdateSelfParticipantSubscriptionInfoSql(final int slotId,
+ final int subscriptionColor, final String subscriptionName, final String where) {
+ return String.format((Locale) null /* construct SQL string without localization */,
+ UPDATE_SELF_PARTICIPANT_SUBSCRIPTION_SQL,
+ slotId, subscriptionColor, subscriptionName, where);
+ }
+
+ /**
+ * Ensure that there is a self participant corresponding to every active SIM. Also, ensure
+ * that any other older SIM self participants are marked as inactive.
+ */
+ private static void refreshSelfParticipantList() {
+ if (!OsUtil.isAtLeastL_MR1()) {
+ return;
+ }
+
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ final List subInfoRecords =
+ PhoneUtils.getDefault().toLMr1().getActiveSubscriptionInfoList();
+ final ArrayMap activeSubscriptionIdToRecordMap =
+ new ArrayMap();
+ db.beginTransaction();
+ final Set existingSubIds = getExistingSubIds();
+
+ try {
+ if (subInfoRecords != null) {
+ for (final SubscriptionInfo subInfoRecord : subInfoRecords) {
+ final int subId = subInfoRecord.getSubscriptionId();
+ // If its a new subscription, add it to the database.
+ if (!existingSubIds.contains(subId)) {
+ db.execSQL(DatabaseHelper.getCreateSelfParticipantSql(subId));
+ // Add it to the local set to guard against duplicated entries returned
+ // by subscription manager.
+ existingSubIds.add(subId);
+ }
+ activeSubscriptionIdToRecordMap.put(subId, subInfoRecord);
+
+ if (subId == PhoneUtils.getDefault().getDefaultSmsSubscriptionId()) {
+ // This is the system default subscription, so update the default self.
+ activeSubscriptionIdToRecordMap.put(ParticipantData.DEFAULT_SELF_SUB_ID,
+ subInfoRecord);
+ }
+ }
+ }
+
+ // For subscriptions already in the database, refresh ParticipantColumns.SIM_SLOT_ID.
+ for (final Integer subId : activeSubscriptionIdToRecordMap.keySet()) {
+ final SubscriptionInfo record = activeSubscriptionIdToRecordMap.get(subId);
+ final String displayName =
+ DatabaseUtils.sqlEscapeString(record.getDisplayName().toString());
+ db.execSQL(getUpdateSelfParticipantSubscriptionInfoSql(record.getSimSlotIndex(),
+ record.getIconTint(), displayName,
+ ParticipantColumns.SUB_ID + " = " + subId));
+ }
+ db.execSQL(getUpdateSelfParticipantSubscriptionInfoSql(
+ ParticipantData.INVALID_SLOT_ID, Color.TRANSPARENT, "''",
+ ParticipantColumns.SUB_ID + " NOT IN (" +
+ Joiner.on(", ").join(activeSubscriptionIdToRecordMap.keySet()) + ")"));
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ // Fix up conversation self ids by reverting to default self for conversations whose self
+ // ids are no longer active.
+ refreshConversationSelfIds();
+ }
+
+ /**
+ * Refresh one participant.
+ * @return true if the ParticipantData was changed
+ */
+ public static boolean refreshParticipant(final DatabaseWrapper db,
+ final ParticipantData participantData) {
+ boolean updated = false;
+
+ if (participantData.isSelf()) {
+ final int selfChange = refreshFromSelfProfile(db, participantData);
+
+ if (selfChange == SELF_PROFILE_EXISTS) {
+ // If a self-profile exists, it takes precedence over Contacts data. So we are done.
+ return true;
+ }
+
+ updated = (selfChange == SELF_PHONE_NUMBER_OR_SUBSCRIPTION_CHANGED);
+
+ // Fall-through and try to update based on Contacts data
+ }
+
+ updated |= refreshFromContacts(db, participantData);
+ return updated;
+ }
+
+ private static final int SELF_PHONE_NUMBER_OR_SUBSCRIPTION_CHANGED = 1;
+ private static final int SELF_PROFILE_EXISTS = 2;
+
+ private static int refreshFromSelfProfile(final DatabaseWrapper db,
+ final ParticipantData participantData) {
+ int changed = 0;
+ // Refresh the phone number based on information from telephony
+ if (participantData.updatePhoneNumberForSelfIfChanged()) {
+ changed = SELF_PHONE_NUMBER_OR_SUBSCRIPTION_CHANGED;
+ }
+
+ if (OsUtil.isAtLeastL_MR1()) {
+ // Refresh the subscription info based on information from SubscriptionManager.
+ final SubscriptionInfo subscriptionInfo =
+ PhoneUtils.get(participantData.getSubId()).toLMr1().getActiveSubscriptionInfo();
+ if (participantData.updateSubscriptionInfoForSelfIfChanged(subscriptionInfo)) {
+ changed = SELF_PHONE_NUMBER_OR_SUBSCRIPTION_CHANGED;
+ }
+ }
+
+ // For self participant, try getting name/avatar from self profile in CP2 first.
+ // TODO: in case of multi-sim, profile would not be able to be used for
+ // different numbers. Need to figure out that.
+ Cursor selfCursor = null;
+ try {
+ selfCursor = ContactUtil.getSelf(db.getContext()).performSynchronousQuery();
+ if (selfCursor != null && selfCursor.getCount() > 0) {
+ selfCursor.moveToNext();
+ final long selfContactId = selfCursor.getLong(ContactUtil.INDEX_CONTACT_ID);
+ participantData.setContactId(selfContactId);
+ participantData.setFullName(selfCursor.getString(
+ ContactUtil.INDEX_DISPLAY_NAME));
+ participantData.setFirstName(
+ ContactUtil.lookupFirstName(db.getContext(), selfContactId));
+ participantData.setProfilePhotoUri(selfCursor.getString(
+ ContactUtil.INDEX_PHOTO_URI));
+ participantData.setLookupKey(selfCursor.getString(
+ ContactUtil.INDEX_SELF_QUERY_LOOKUP_KEY));
+ return SELF_PROFILE_EXISTS;
+ }
+ } catch (final Exception exception) {
+ // It's possible for contact query to fail and we don't want that to crash our app.
+ // However, we need to at least log the exception so we know something was wrong.
+ LogUtil.e(LogUtil.BUGLE_DATAMODEL_TAG, "Participant refresh: failed to refresh " +
+ "participant. exception=" + exception);
+ } finally {
+ if (selfCursor != null) {
+ selfCursor.close();
+ }
+ }
+ return changed;
+ }
+
+ private static boolean refreshFromContacts(final DatabaseWrapper db,
+ final ParticipantData participantData) {
+ final String normalizedDestination = participantData.getNormalizedDestination();
+ final long currentContactId = participantData.getContactId();
+ final String currentDisplayName = participantData.getFullName();
+ final String currentFirstName = participantData.getFirstName();
+ final String currentPhotoUri = participantData.getProfilePhotoUri();
+ final String currentContactDestination = participantData.getContactDestination();
+
+ Cursor matchingContactCursor = null;
+ long matchingContactId = -1;
+ String matchingDisplayName = null;
+ String matchingFirstName = null;
+ String matchingPhotoUri = null;
+ String matchingLookupKey = null;
+ String matchingDestination = null;
+ boolean updated = false;
+
+ if (TextUtils.isEmpty(normalizedDestination)) {
+ // The normalized destination can be "" for the self id if we can't get it from the
+ // SIM. Some contact providers throw an IllegalArgumentException if you lookup "",
+ // so we early out.
+ return false;
+ }
+
+ try {
+ matchingContactCursor = ContactUtil.lookupDestination(db.getContext(),
+ normalizedDestination).performSynchronousQuery();
+ if (matchingContactCursor == null || matchingContactCursor.getCount() == 0) {
+ // If there is no match, mark the participant as contact not found.
+ if (currentContactId != ParticipantData.PARTICIPANT_CONTACT_ID_NOT_FOUND) {
+ participantData.setContactId(ParticipantData.PARTICIPANT_CONTACT_ID_NOT_FOUND);
+ participantData.setFullName(null);
+ participantData.setFirstName(null);
+ participantData.setProfilePhotoUri(null);
+ participantData.setLookupKey(null);
+ updated = true;
+ }
+ return updated;
+ }
+
+ while (matchingContactCursor.moveToNext()) {
+ final long contactId = matchingContactCursor.getLong(ContactUtil.INDEX_CONTACT_ID);
+ // Pick either the first contact or the contact with same id as previous matched
+ // contact id.
+ if (matchingContactId == -1 || currentContactId == contactId) {
+ matchingContactId = contactId;
+ matchingDisplayName = matchingContactCursor.getString(
+ ContactUtil.INDEX_DISPLAY_NAME);
+ matchingFirstName = ContactUtil.lookupFirstName(db.getContext(), contactId);
+ matchingPhotoUri = matchingContactCursor.getString(
+ ContactUtil.INDEX_PHOTO_URI);
+ matchingLookupKey = matchingContactCursor.getString(
+ ContactUtil.INDEX_LOOKUP_KEY);
+ matchingDestination = matchingContactCursor.getString(
+ ContactUtil.INDEX_PHONE_EMAIL);
+ }
+
+ // There is no need to try other contacts if the current contactId was not filled...
+ if (currentContactId < 0
+ // or we found the matching contact id
+ || currentContactId == contactId) {
+ break;
+ }
+ }
+ } catch (final Exception exception) {
+ // It's possible for contact query to fail and we don't want that to crash our app.
+ // However, we need to at least log the exception so we know something was wrong.
+ LogUtil.e(LogUtil.BUGLE_DATAMODEL_TAG, "Participant refresh: failed to refresh " +
+ "participant. exception=" + exception);
+ return false;
+ } finally {
+ if (matchingContactCursor != null) {
+ matchingContactCursor.close();
+ }
+ }
+
+ // Update participant only if something changed.
+ final boolean isContactIdChanged = (matchingContactId != currentContactId);
+ final boolean isDisplayNameChanged =
+ !TextUtils.equals(matchingDisplayName, currentDisplayName);
+ final boolean isFirstNameChanged = !TextUtils.equals(matchingFirstName, currentFirstName);
+ final boolean isPhotoUrlChanged = !TextUtils.equals(matchingPhotoUri, currentPhotoUri);
+ final boolean isDestinationChanged = !TextUtils.equals(matchingDestination,
+ currentContactDestination);
+
+ if (isContactIdChanged || isDisplayNameChanged || isFirstNameChanged || isPhotoUrlChanged
+ || isDestinationChanged) {
+ participantData.setContactId(matchingContactId);
+ participantData.setFullName(matchingDisplayName);
+ participantData.setFirstName(matchingFirstName);
+ participantData.setProfilePhotoUri(matchingPhotoUri);
+ participantData.setLookupKey(matchingLookupKey);
+ participantData.setContactDestination(matchingDestination);
+ if (isDestinationChanged) {
+ // Update the send destination to the new one entered by user in Contacts.
+ participantData.setSendDestination(matchingDestination);
+ }
+ updated = true;
+ }
+
+ return updated;
+ }
+
+ /**
+ * Update participant with matching contact's contactId, displayName and photoUri.
+ */
+ private static void updateParticipant(final DatabaseWrapper db,
+ final ParticipantData participantData) {
+ final ContentValues values = new ContentValues();
+ if (participantData.isSelf()) {
+ // Self participants can refresh their normalized phone numbers
+ values.put(ParticipantColumns.NORMALIZED_DESTINATION,
+ participantData.getNormalizedDestination());
+ values.put(ParticipantColumns.DISPLAY_DESTINATION,
+ participantData.getDisplayDestination());
+ }
+ values.put(ParticipantColumns.CONTACT_ID, participantData.getContactId());
+ values.put(ParticipantColumns.LOOKUP_KEY, participantData.getLookupKey());
+ values.put(ParticipantColumns.FULL_NAME, participantData.getFullName());
+ values.put(ParticipantColumns.FIRST_NAME, participantData.getFirstName());
+ values.put(ParticipantColumns.PROFILE_PHOTO_URI, participantData.getProfilePhotoUri());
+ values.put(ParticipantColumns.CONTACT_DESTINATION, participantData.getContactDestination());
+ values.put(ParticipantColumns.SEND_DESTINATION, participantData.getSendDestination());
+
+ db.beginTransaction();
+ try {
+ db.update(DatabaseHelper.PARTICIPANTS_TABLE, values, ParticipantColumns._ID + "=?",
+ new String[] { participantData.getId() });
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+ }
+
+ /**
+ * Get a list of inactive self ids in the participants table.
+ */
+ private static List getInactiveSelfParticipantIds() {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final List inactiveSelf = new ArrayList();
+
+ final String selection = ParticipantColumns.SIM_SLOT_ID + "=? AND " +
+ SELF_PARTICIPANTS_CLAUSE;
+ Cursor cursor = null;
+ try {
+ cursor = db.query(DatabaseHelper.PARTICIPANTS_TABLE,
+ new String[] { ParticipantColumns._ID },
+ selection, new String[] { String.valueOf(ParticipantData.INVALID_SLOT_ID) },
+ null, null, null);
+
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ final String participantId = cursor.getString(0);
+ inactiveSelf.add(participantId);
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+
+ return inactiveSelf;
+ }
+
+ /**
+ * Gets a list of conversations with the given self ids.
+ */
+ private static List getConversationsWithSelfParticipantIds(final List selfIds) {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final List conversationIds = new ArrayList();
+
+ Cursor cursor = null;
+ try {
+ final StringBuilder selectionList = new StringBuilder();
+ for (int i = 0; i < selfIds.size(); i++) {
+ selectionList.append('?');
+ if (i < selfIds.size() - 1) {
+ selectionList.append(',');
+ }
+ }
+ final String selection =
+ ConversationColumns.CURRENT_SELF_ID + " IN (" + selectionList + ")";
+ cursor = db.query(DatabaseHelper.CONVERSATIONS_TABLE,
+ new String[] { ConversationColumns._ID },
+ selection, selfIds.toArray(new String[0]),
+ null, null, null);
+
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ final String conversationId = cursor.getString(0);
+ conversationIds.add(conversationId);
+ }
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+ return conversationIds;
+ }
+
+ /**
+ * Refresh one conversation's self id.
+ */
+ private static void updateConversationSelfId(final String conversationId,
+ final String selfId) {
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+
+ db.beginTransaction();
+ try {
+ BugleDatabaseOperations.updateConversationSelfIdInTransaction(db, conversationId,
+ selfId);
+ db.setTransactionSuccessful();
+ } finally {
+ db.endTransaction();
+ }
+
+ MessagingContentProvider.notifyMessagesChanged(conversationId);
+ MessagingContentProvider.notifyConversationMetadataChanged(conversationId);
+ UIIntents.get().broadcastConversationSelfIdChange(db.getContext(), conversationId, selfId);
+ }
+
+ /**
+ * After refreshing the self participant list, find all conversations with inactive self ids,
+ * and switch them back to system default.
+ */
+ private static void refreshConversationSelfIds() {
+ final List inactiveSelfs = getInactiveSelfParticipantIds();
+ if (inactiveSelfs.size() == 0) {
+ return;
+ }
+ final List conversationsToRefresh =
+ getConversationsWithSelfParticipantIds(inactiveSelfs);
+ if (conversationsToRefresh.size() == 0) {
+ return;
+ }
+ final DatabaseWrapper db = DataModel.get().getDatabase();
+ final ParticipantData defaultSelf =
+ BugleDatabaseOperations.getOrCreateSelf(db, ParticipantData.DEFAULT_SELF_SUB_ID);
+
+ if (defaultSelf != null) {
+ for (final String conversationId : conversationsToRefresh) {
+ updateConversationSelfId(conversationId, defaultSelf.getId());
+ }
+ }
+ }
+}
diff --git a/src/com/android/messaging/datamodel/SyncManager.java b/src/com/android/messaging/datamodel/SyncManager.java
new file mode 100644
index 0000000..b3571bf
--- /dev/null
+++ b/src/com/android/messaging/datamodel/SyncManager.java
@@ -0,0 +1,478 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.datamodel;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.provider.Telephony;
+import android.support.v4.util.LongSparseArray;
+
+import com.android.messaging.datamodel.action.SyncMessagesAction;
+import com.android.messaging.datamodel.data.ParticipantData;
+import com.android.messaging.sms.MmsUtils;
+import com.android.messaging.util.Assert;
+import com.android.messaging.util.BugleGservices;
+import com.android.messaging.util.BugleGservicesKeys;
+import com.android.messaging.util.BuglePrefs;
+import com.android.messaging.util.BuglePrefsKeys;
+import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.OsUtil;
+import com.android.messaging.util.PhoneUtils;
+import com.google.common.collect.Lists;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * This class manages message sync with the Telephony SmsProvider/MmsProvider.
+ */
+public class SyncManager {
+ private static final String TAG = LogUtil.BUGLE_TAG;
+
+ /**
+ * Record of any user customization to conversation settings
+ */
+ public static class ConversationCustomization {
+ private final boolean mArchived;
+ private final boolean mMuted;
+ private final boolean mNoVibrate;
+ private final String mNotificationSoundUri;
+
+ public ConversationCustomization(final boolean archived, final boolean muted,
+ final boolean noVibrate, final String notificationSoundUri) {
+ mArchived = archived;
+ mMuted = muted;
+ mNoVibrate = noVibrate;
+ mNotificationSoundUri = notificationSoundUri;
+ }
+
+ public boolean isArchived() {
+ return mArchived;
+ }
+
+ public boolean isMuted() {
+ return mMuted;
+ }
+
+ public boolean noVibrate() {
+ return mNoVibrate;
+ }
+
+ public String getNotificationSoundUri() {
+ return mNotificationSoundUri;
+ }
+ }
+
+ SyncManager() {
+ }
+
+ /**
+ * Timestamp of in progress sync - used to keep track of whether sync is running
+ */
+ private long mSyncInProgressTimestamp = -1;
+
+ /**
+ * Timestamp of current sync batch upper bound - used to determine if message makes batch dirty
+ */
+ private long mCurrentUpperBoundTimestamp = -1;
+
+ /**
+ * Timestamp of messages inserted since sync batch started - used to determine if batch dirty
+ */
+ private long mMaxRecentChangeTimestamp = -1L;
+
+ private final ThreadInfoCache mThreadInfoCache = new ThreadInfoCache();
+
+ /**
+ * User customization to conversations. If this is set, we need to recover them after
+ * a full sync.
+ */
+ private LongSparseArray mCustomization = null;
+
+ /**
+ * Start an incremental sync (backed off a few seconds)
+ */
+ public static void sync() {
+ SyncMessagesAction.sync();
+ }
+
+ /**
+ * Start an incremental sync (with no backoff)
+ */
+ public static void immediateSync() {
+ SyncMessagesAction.immediateSync();
+ }
+
+ /**
+ * Start a full sync (for debugging)
+ */
+ public static void forceSync() {
+ SyncMessagesAction.fullSync();
+ }
+
+ /**
+ * Called from data model thread when starting a sync batch
+ * @param upperBoundTimestamp upper bound timestamp for sync batch
+ */
+ public synchronized void startSyncBatch(final long upperBoundTimestamp) {
+ Assert.isTrue(mCurrentUpperBoundTimestamp < 0);
+ mCurrentUpperBoundTimestamp = upperBoundTimestamp;
+ mMaxRecentChangeTimestamp = -1L;
+ }
+
+ /**
+ * Called from data model thread at end of batch to determine if any messages added in window
+ * @param lowerBoundTimestamp lower bound timestamp for sync batch
+ * @return true if message added within window from lower to upper bound timestamp of batch
+ */
+ public synchronized boolean isBatchDirty(final long lowerBoundTimestamp) {
+ Assert.isTrue(mCurrentUpperBoundTimestamp >= 0);
+ final long max = mMaxRecentChangeTimestamp;
+
+ final boolean dirty = (max >= 0 && max >= lowerBoundTimestamp);
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: Sync batch of messages from " + lowerBoundTimestamp
+ + " to " + mCurrentUpperBoundTimestamp + " is "
+ + (dirty ? "DIRTY" : "clean") + "; max change timestamp = "
+ + mMaxRecentChangeTimestamp);
+ }
+
+ mCurrentUpperBoundTimestamp = -1L;
+ mMaxRecentChangeTimestamp = -1L;
+
+ return dirty;
+ }
+
+ /**
+ * Called from data model or background worker thread to indicate start of message add process
+ * (add must complete on that thread before action transitions to new thread/stage)
+ * @param timestamp timestamp of message being added
+ */
+ public synchronized void onNewMessageInserted(final long timestamp) {
+ if (mCurrentUpperBoundTimestamp >= 0 && timestamp <= mCurrentUpperBoundTimestamp) {
+ // Message insert in current sync window
+ mMaxRecentChangeTimestamp = Math.max(mCurrentUpperBoundTimestamp, timestamp);
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: New message @ " + timestamp + " before upper bound of "
+ + "current sync batch " + mCurrentUpperBoundTimestamp);
+ }
+ } else if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: New message @ " + timestamp + " after upper bound of "
+ + "current sync batch " + mCurrentUpperBoundTimestamp);
+ }
+ }
+
+ /**
+ * Synchronously checks whether sync is allowed and starts sync if allowed
+ * @param full - true indicates a full (not incremental) sync operation
+ * @param startTimestamp - starttimestamp for this sync (if allowed)
+ * @return - true if sync should start
+ */
+ public synchronized boolean shouldSync(final boolean full, final long startTimestamp) {
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "SyncManager: Checking shouldSync " + (full ? "full " : "")
+ + "at " + startTimestamp);
+ }
+
+ if (full) {
+ final long delayUntilFullSync = delayUntilFullSync(startTimestamp);
+ if (delayUntilFullSync > 0) {
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: Full sync requested for " + startTimestamp
+ + " delayed for " + delayUntilFullSync + " ms");
+ }
+ return false;
+ }
+ }
+
+ if (isSyncing()) {
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: Not allowed to " + (full ? "full " : "")
+ + "sync yet; still running sync started at " + mSyncInProgressTimestamp);
+ }
+ return false;
+ }
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: Starting " + (full ? "full " : "") + "sync at "
+ + startTimestamp);
+ }
+
+ mSyncInProgressTimestamp = startTimestamp;
+
+ return true;
+ }
+
+ /**
+ * Return delay (in ms) until allowed to run a full sync (0 meaning can run immediately)
+ * @param startTimestamp Timestamp used to start the sync
+ * @return 0 if allowed to run now, else delay in ms
+ */
+ public long delayUntilFullSync(final long startTimestamp) {
+ final BugleGservices bugleGservices = BugleGservices.get();
+ final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+
+ final long lastFullSyncTime = prefs.getLong(BuglePrefsKeys.LAST_FULL_SYNC_TIME, -1L);
+ final long smsFullSyncBackoffTimeMillis = bugleGservices.getLong(
+ BugleGservicesKeys.SMS_FULL_SYNC_BACKOFF_TIME_MILLIS,
+ BugleGservicesKeys.SMS_FULL_SYNC_BACKOFF_TIME_MILLIS_DEFAULT);
+ final long noFullSyncBefore = (lastFullSyncTime < 0 ? startTimestamp :
+ lastFullSyncTime + smsFullSyncBackoffTimeMillis);
+
+ final long delayUntilFullSync = noFullSyncBefore - startTimestamp;
+ if (delayUntilFullSync > 0) {
+ return delayUntilFullSync;
+ }
+ return 0;
+ }
+
+ /**
+ * Check if sync currently in progress (public for asserts/logging).
+ */
+ public synchronized boolean isSyncing() {
+ return (mSyncInProgressTimestamp >= 0);
+ }
+
+ /**
+ * Check if sync batch should be in progress - compares upperBound with in memory value
+ * @param upperBoundTimestamp - upperbound timestamp for sync batch
+ * @return - true if timestamps match (otherwise batch is orphan from older process)
+ */
+ public synchronized boolean isSyncing(final long upperBoundTimestamp) {
+ Assert.isTrue(upperBoundTimestamp >= 0);
+ return (upperBoundTimestamp == mCurrentUpperBoundTimestamp);
+ }
+
+ /**
+ * Check if sync has completed for the first time.
+ */
+ public boolean getHasFirstSyncCompleted() {
+ final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+ return prefs.getLong(BuglePrefsKeys.LAST_SYNC_TIME,
+ BuglePrefsKeys.LAST_SYNC_TIME_DEFAULT) !=
+ BuglePrefsKeys.LAST_SYNC_TIME_DEFAULT;
+ }
+
+ /**
+ * Called once sync is complete
+ */
+ public synchronized void complete() {
+ if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) {
+ LogUtil.d(TAG, "SyncManager: Sync started at " + mSyncInProgressTimestamp
+ + " marked as complete");
+ }
+ mSyncInProgressTimestamp = -1L;
+ // Conversation customization only used once
+ mCustomization = null;
+ }
+
+ private final ContentObserver mMmsSmsObserver = new TelephonyMessagesObserver();
+ private boolean mSyncOnChanges = false;
+ private boolean mNotifyOnChanges = false;
+
+ /**
+ * Register content observer when necessary and kick off a catch up sync
+ */
+ public void updateSyncObserver(final Context context) {
+ registerObserver(context);
+ // Trigger an sms sync in case we missed and messages before registering this observer or
+ // becoming the SMS provider.
+ immediateSync();
+ }
+
+ private void registerObserver(final Context context) {
+ if (!PhoneUtils.getDefault().isDefaultSmsApp()) {
+ // Not default SMS app - need to actively monitor telephony but not notify
+ mNotifyOnChanges = false;
+ mSyncOnChanges = true;
+ } else if (OsUtil.isSecondaryUser()){
+ // Secondary users default SMS app - need to actively monitor telephony and notify
+ mNotifyOnChanges = true;
+ mSyncOnChanges = true;
+ } else {
+ // Primary users default SMS app - don't monitor telephony (most changes from this app)
+ mNotifyOnChanges = false;
+ mSyncOnChanges = false;
+ }
+ if (mNotifyOnChanges || mSyncOnChanges) {
+ context.getContentResolver().registerContentObserver(Telephony.MmsSms.CONTENT_URI,
+ true, mMmsSmsObserver);
+ } else {
+ context.getContentResolver().unregisterContentObserver(mMmsSmsObserver);
+ }
+ }
+
+ public synchronized void setCustomization(
+ final LongSparseArray customization) {
+ this.mCustomization = customization;
+ }
+
+ public synchronized ConversationCustomization getCustomizationForThread(final long threadId) {
+ if (mCustomization != null) {
+ return mCustomization.get(threadId);
+ }
+ return null;
+ }
+
+ public static void resetLastSyncTimestamps() {
+ final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+ prefs.putLong(BuglePrefsKeys.LAST_FULL_SYNC_TIME,
+ BuglePrefsKeys.LAST_FULL_SYNC_TIME_DEFAULT);
+ prefs.putLong(BuglePrefsKeys.LAST_SYNC_TIME, BuglePrefsKeys.LAST_SYNC_TIME_DEFAULT);
+ }
+
+ private class TelephonyMessagesObserver extends ContentObserver {
+ public TelephonyMessagesObserver() {
+ // Just run on default thread
+ super(null);
+ }
+
+ // Implement the onChange(boolean) method to delegate the change notification to
+ // the onChange(boolean, Uri) method to ensure correct operation on older versions
+ // of the framework that did not have the onChange(boolean, Uri) method.
+ @Override
+ public void onChange(final boolean selfChange) {
+ onChange(selfChange, null);
+ }
+
+ // Implement the onChange(boolean, Uri) method to take advantage of the new Uri argument.
+ @Override
+ public void onChange(final boolean selfChange, final Uri uri) {
+ // Handle change.
+ if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
+ LogUtil.v(TAG, "SyncManager: Sms/Mms DB changed @" + System.currentTimeMillis()
+ + " for " + (uri == null ? "" : uri.toString()) + " "
+ + mSyncOnChanges + "/" + mNotifyOnChanges);
+ }
+
+ if (mSyncOnChanges) {
+ // If sync is already running this will do nothing - but at end of each sync
+ // action there is a check for recent messages that should catch new changes.
+ SyncManager.immediateSync();
+ }
+ if (mNotifyOnChanges) {
+ // TODO: Secondary users are not going to get notifications
+ }
+ }
+ }
+
+ public ThreadInfoCache getThreadInfoCache() {
+ return mThreadInfoCache;
+ }
+
+ public static class ThreadInfoCache {
+ // Cache of thread->conversationId map
+ private final LongSparseArray mThreadToConversationId =
+ new LongSparseArray();
+
+ // Cache of thread->recipients map
+ private final LongSparseArray> mThreadToRecipients =
+ new LongSparseArray>();
+
+ // Remember the conversation ids that need to be archived
+ private final HashSet