Java tutorial
/* * 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()); } } } }