| /* |
| * 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<String> changedParticipants = new ArrayList<String>(); |
| |
| 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<Integer> getExistingSubIds() { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final HashSet<Integer> existingSubIds = new HashSet<Integer>(); |
| |
| 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<SubscriptionInfo> subInfoRecords = |
| PhoneUtils.getDefault().toLMr1().getActiveSubscriptionInfoList(); |
| final ArrayMap<Integer, SubscriptionInfo> activeSubscriptionIdToRecordMap = |
| new ArrayMap<Integer, SubscriptionInfo>(); |
| db.beginTransaction(); |
| final Set<Integer> 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<String> getInactiveSelfParticipantIds() { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final List<String> inactiveSelf = new ArrayList<String>(); |
| |
| 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<String> getConversationsWithSelfParticipantIds(final List<String> selfIds) { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final List<String> conversationIds = new ArrayList<String>(); |
| |
| 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<String> inactiveSelfs = getInactiveSelfParticipantIds(); |
| if (inactiveSelfs.size() == 0) { |
| return; |
| } |
| final List<String> 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()); |
| } |
| } |
| } |
| } |
