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.action; import android.content.Context; import android.database.Cursor; import android.database.sqlite.SQLiteException; import android.provider.Telephony.Mms; import android.provider.Telephony.Sms; import android.support.v4.util.LongSparseArray; import android.text.TextUtils; import com.android.messaging.Factory; import com.android.messaging.datamodel.DatabaseHelper; import com.android.messaging.datamodel.DatabaseWrapper; import com.android.messaging.datamodel.SyncManager; import com.android.messaging.datamodel.DatabaseHelper.MessageColumns; import com.android.messaging.datamodel.SyncManager.ThreadInfoCache; import com.android.messaging.datamodel.data.MessageData; import com.android.messaging.mmslib.SqliteWrapper; import com.android.messaging.sms.DatabaseMessages; import com.android.messaging.sms.DatabaseMessages.DatabaseMessage; import com.android.messaging.sms.DatabaseMessages.LocalDatabaseMessage; import com.android.messaging.sms.DatabaseMessages.MmsMessage; import com.android.messaging.sms.DatabaseMessages.SmsMessage; import com.android.messaging.sms.MmsUtils; import com.android.messaging.util.Assert; import com.android.messaging.util.LogUtil; import com.google.common.collect.Sets; import java.util.ArrayList; import java.util.List; import java.util.Locale; import java.util.Set; /** * Class holding a pair of cursors - one for local db and one for telephony provider - allowing * synchronous stepping through messages as part of sync. */ class SyncCursorPair { private static final String TAG = LogUtil.BUGLE_TAG; static final long SYNC_COMPLETE = -1L; static final long SYNC_STARTING = Long.MAX_VALUE; private CursorIterator mLocalCursorIterator; private CursorIterator mRemoteCursorsIterator; private final String mLocalSelection; private final String mRemoteSmsSelection; private final String mRemoteMmsSelection; /** * Check if SMS has been synchronized. We compare the counts of messages on both * sides and return true if they are equal. * * Note that this may not be the most reliable way to tell if messages are in sync. * For example, the local misses one message and has one obsolete message. * However, we have background sms sync once a while, also some other events might * trigger a full sync. So we will eventually catch up. And this should be rare to * happen. * * @return If sms is in sync with telephony sms/mms providers */ static boolean allSynchronized(final DatabaseWrapper db) { return isSynchronized(db, LOCAL_MESSAGES_SELECTION, null, getSmsTypeSelectionSql(), null, getMmsTypeSelectionSql(), null); } SyncCursorPair(final long lowerBound, final long upperBound) { mLocalSelection = getTimeConstrainedQuery(LOCAL_MESSAGES_SELECTION, MessageColumns.RECEIVED_TIMESTAMP, lowerBound, upperBound, null /* threadColumn */, null /* threadId */); mRemoteSmsSelection = getTimeConstrainedQuery(getSmsTypeSelectionSql(), "date", lowerBound, upperBound, null /* threadColumn */, null /* threadId */); mRemoteMmsSelection = getTimeConstrainedQuery(getMmsTypeSelectionSql(), "date", ((lowerBound < 0) ? lowerBound : (lowerBound + 999) / 1000), /*seconds*/ ((upperBound < 0) ? upperBound : (upperBound + 999) / 1000), /*seconds*/ null /* threadColumn */, null /* threadId */); } SyncCursorPair(final long threadId, final String conversationId) { mLocalSelection = getTimeConstrainedQuery(LOCAL_MESSAGES_SELECTION, MessageColumns.RECEIVED_TIMESTAMP, -1L, -1L, MessageColumns.CONVERSATION_ID, conversationId); // Find all SMS messages (excluding drafts) within the sync window mRemoteSmsSelection = getTimeConstrainedQuery(getSmsTypeSelectionSql(), "date", -1L, -1L, Sms.THREAD_ID, Long.toString(threadId)); mRemoteMmsSelection = getTimeConstrainedQuery(getMmsTypeSelectionSql(), "date", -1L, /*seconds*/ -1L, /*seconds*/ Mms.THREAD_ID, Long.toString(threadId)); } void query(final DatabaseWrapper db) { // Load local messages in the sync window mLocalCursorIterator = new LocalCursorIterator(db, mLocalSelection); // Load remote messages in the sync window mRemoteCursorsIterator = new RemoteCursorsIterator(mRemoteSmsSelection, mRemoteMmsSelection); } boolean isSynchronized(final DatabaseWrapper db) { return isSynchronized(db, mLocalSelection, null, mRemoteSmsSelection, null, mRemoteMmsSelection, null); } void close() { if (mLocalCursorIterator != null) { mLocalCursorIterator.close(); } if (mRemoteCursorsIterator != null) { mRemoteCursorsIterator.close(); } } long scan(final int maxMessagesToScan, final int maxMessagesToUpdate, final ArrayList<SmsMessage> smsToAdd, final LongSparseArray<MmsMessage> mmsToAdd, final ArrayList<LocalDatabaseMessage> messagesToDelete, final SyncManager.ThreadInfoCache threadInfoCache) { // Set of local messages matched with the timestamp of a remote message final Set<DatabaseMessage> matchedLocalMessages = Sets.newHashSet(); // Set of remote messages matched with the timestamp of a local message final Set<DatabaseMessage> matchedRemoteMessages = Sets.newHashSet(); long lastTimestampMillis = SYNC_STARTING; // Number of messages scanned local and remote int localCount = 0; int remoteCount = 0; // Seed the initial values of remote and local messages for comparison DatabaseMessage remoteMessage = mRemoteCursorsIterator.next(); DatabaseMessage localMessage = mLocalCursorIterator.next(); // Iterate through messages on both sides in reverse time order // Import messages in remote not in local, delete messages in local not in remote while (localCount + remoteCount < maxMessagesToScan && smsToAdd.size() + mmsToAdd.size() + messagesToDelete.size() < maxMessagesToUpdate) { if (remoteMessage == null && localMessage == null) { // No more message on both sides - scan complete lastTimestampMillis = SYNC_COMPLETE; break; } else if ((remoteMessage == null && localMessage != null) || (localMessage != null && remoteMessage != null && localMessage.getTimestampInMillis() > remoteMessage.getTimestampInMillis())) { // Found a local message that is not in remote db // Delete the local message messagesToDelete.add((LocalDatabaseMessage) localMessage); lastTimestampMillis = Math.min(lastTimestampMillis, localMessage.getTimestampInMillis()); // Advance to next local message localMessage = mLocalCursorIterator.next(); localCount += 1; } else if ((localMessage == null && remoteMessage != null) || (localMessage != null && remoteMessage != null && localMessage.getTimestampInMillis() < remoteMessage.getTimestampInMillis())) { // Found a remote message that is not in local db // Add the remote message saveMessageToAdd(smsToAdd, mmsToAdd, remoteMessage, threadInfoCache); lastTimestampMillis = Math.min(lastTimestampMillis, remoteMessage.getTimestampInMillis()); // Advance to next remote message remoteMessage = mRemoteCursorsIterator.next(); remoteCount += 1; } else { // Found remote and local messages at the same timestamp final long matchedTimestamp = localMessage.getTimestampInMillis(); lastTimestampMillis = Math.min(lastTimestampMillis, matchedTimestamp); // Get the next local and remote messages final DatabaseMessage remoteMessagePeek = mRemoteCursorsIterator.next(); final DatabaseMessage localMessagePeek = mLocalCursorIterator.next(); // Check if only one message on each side matches the current timestamp // by looking at the next messages on both sides. If they are either null // (meaning no more messages) or having a different timestamp. We want // to optimize for this since this is the most common case when majority // of the messages are in sync (so they one-to-one pair up at each timestamp), // by not allocating the data structures required to compare a set of // messages from both sides. if ((remoteMessagePeek == null || remoteMessagePeek.getTimestampInMillis() != matchedTimestamp) && (localMessagePeek == null || localMessagePeek.getTimestampInMillis() != matchedTimestamp)) { // Optimize the common case where only one message on each side // that matches the same timestamp if (!remoteMessage.equals(localMessage)) { // local != remote // Delete local message messagesToDelete.add((LocalDatabaseMessage) localMessage); // Add remote message saveMessageToAdd(smsToAdd, mmsToAdd, remoteMessage, threadInfoCache); } // Get next local and remote messages localMessage = localMessagePeek; remoteMessage = remoteMessagePeek; localCount += 1; remoteCount += 1; } else { // Rare case in which multiple messages are in the same timestamp // on either or both sides // Gather all the matched remote messages matchedRemoteMessages.clear(); matchedRemoteMessages.add(remoteMessage); remoteCount += 1; remoteMessage = remoteMessagePeek; while (remoteMessage != null && remoteMessage.getTimestampInMillis() == matchedTimestamp) { Assert.isTrue(!matchedRemoteMessages.contains(remoteMessage)); matchedRemoteMessages.add(remoteMessage); remoteCount += 1; remoteMessage = mRemoteCursorsIterator.next(); } // Gather all the matched local messages matchedLocalMessages.clear(); matchedLocalMessages.add(localMessage); localCount += 1; localMessage = localMessagePeek; while (localMessage != null && localMessage.getTimestampInMillis() == matchedTimestamp) { if (matchedLocalMessages.contains(localMessage)) { // Duplicate message is local database is deleted messagesToDelete.add((LocalDatabaseMessage) localMessage); } else { matchedLocalMessages.add(localMessage); } localCount += 1; localMessage = mLocalCursorIterator.next(); } // Delete messages local only for (final DatabaseMessage msg : Sets.difference(matchedLocalMessages, matchedRemoteMessages)) { messagesToDelete.add((LocalDatabaseMessage) msg); } // Add messages remote only for (final DatabaseMessage msg : Sets.difference(matchedRemoteMessages, matchedLocalMessages)) { saveMessageToAdd(smsToAdd, mmsToAdd, msg, threadInfoCache); } } } } return lastTimestampMillis; } DatabaseMessage getLocalMessage() { return mLocalCursorIterator.next(); } DatabaseMessage getRemoteMessage() { return mRemoteCursorsIterator.next(); } int getLocalPosition() { return mLocalCursorIterator.getPosition(); } int getRemotePosition() { return mRemoteCursorsIterator.getPosition(); } int getLocalCount() { return mLocalCursorIterator.getCount(); } int getRemoteCount() { return mRemoteCursorsIterator.getCount(); } /** * An iterator for a database cursor */ interface CursorIterator { /** * Move to next element in the cursor * * @return The next element (which becomes the current) */ public DatabaseMessage next(); /** * Close the cursor */ public void close(); /** * Get the position */ public int getPosition(); /** * Get the count */ public int getCount(); } private static final String ORDER_BY_DATE_DESC = "date DESC"; // A subquery that selects SMS/MMS messages in Bugle which are also in telephony private static final String LOCAL_MESSAGES_SELECTION = String.format(Locale.US, "(%s NOTNULL)", MessageColumns.SMS_MESSAGE_URI); private static final String ORDER_BY_TIMESTAMP_DESC = MessageColumns.RECEIVED_TIMESTAMP + " DESC"; // TODO : This should move into the provider private static class LocalMessageQuery { private static final String[] PROJECTION = new String[] { MessageColumns._ID, MessageColumns.RECEIVED_TIMESTAMP, MessageColumns.SMS_MESSAGE_URI, MessageColumns.PROTOCOL, MessageColumns.CONVERSATION_ID, }; private static final int INDEX_MESSAGE_ID = 0; private static final int INDEX_MESSAGE_TIMESTAMP = 1; private static final int INDEX_SMS_MESSAGE_URI = 2; private static final int INDEX_MESSAGE_SMS_TYPE = 3; private static final int INDEX_CONVERSATION_ID = 4; } /** * This class provides the same DatabaseMessage interface over a local SMS db message */ private static LocalDatabaseMessage getLocalDatabaseMessage(final Cursor cursor) { if (cursor == null) { return null; } return new LocalDatabaseMessage(cursor.getLong(LocalMessageQuery.INDEX_MESSAGE_ID), cursor.getInt(LocalMessageQuery.INDEX_MESSAGE_SMS_TYPE), cursor.getString(LocalMessageQuery.INDEX_SMS_MESSAGE_URI), cursor.getLong(LocalMessageQuery.INDEX_MESSAGE_TIMESTAMP), cursor.getString(LocalMessageQuery.INDEX_CONVERSATION_ID)); } /** * The buffered cursor iterator for local SMS */ private static class LocalCursorIterator implements CursorIterator { private Cursor mCursor; private final DatabaseWrapper mDatabase; LocalCursorIterator(final DatabaseWrapper database, final String selection) throws SQLiteException { mDatabase = database; try { if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { LogUtil.v(TAG, "SyncCursorPair: Querying for local messages; selection = " + selection); } mCursor = mDatabase.query(DatabaseHelper.MESSAGES_TABLE, LocalMessageQuery.PROJECTION, selection, null /*selectionArgs*/, null/*groupBy*/, null/*having*/, ORDER_BY_TIMESTAMP_DESC); } catch (final SQLiteException e) { LogUtil.e(TAG, "SyncCursorPair: failed to query local sms/mms", e); // Can't query local database. So let's throw up the exception and abort sync // because we may end up import duplicate messages. throw e; } } @Override public DatabaseMessage next() { if (mCursor != null && mCursor.moveToNext()) { return getLocalDatabaseMessage(mCursor); } return null; } @Override public int getCount() { return (mCursor == null ? 0 : mCursor.getCount()); } @Override public int getPosition() { return (mCursor == null ? 0 : mCursor.getPosition()); } @Override public void close() { if (mCursor != null) { mCursor.close(); mCursor = null; } } } /** * The cursor iterator for remote sms. * Since SMS and MMS are stored in different tables in telephony provider, * this class merges the two cursors and provides a unified view of messages * from both cursors. Note that the order is DESC. */ private static class RemoteCursorsIterator implements CursorIterator { private Cursor mSmsCursor; private Cursor mMmsCursor; private DatabaseMessage mNextSms; private DatabaseMessage mNextMms; RemoteCursorsIterator(final String smsSelection, final String mmsSelection) throws SQLiteException { mSmsCursor = null; mMmsCursor = null; try { final Context context = Factory.get().getApplicationContext(); if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { LogUtil.v(TAG, "SyncCursorPair: Querying for remote SMS; selection = " + smsSelection); } mSmsCursor = SqliteWrapper.query(context, context.getContentResolver(), Sms.CONTENT_URI, SmsMessage.getProjection(), smsSelection, null /* selectionArgs */, ORDER_BY_DATE_DESC); if (mSmsCursor == null) { LogUtil.w(TAG, "SyncCursorPair: Remote SMS query returned null cursor; " + "need to cancel sync"); throw new RuntimeException("Null cursor from remote SMS query"); } if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { LogUtil.v(TAG, "SyncCursorPair: Querying for remote MMS; selection = " + mmsSelection); } mMmsCursor = SqliteWrapper.query(context, context.getContentResolver(), Mms.CONTENT_URI, DatabaseMessages.MmsMessage.getProjection(), mmsSelection, null /* selectionArgs */, ORDER_BY_DATE_DESC); if (mMmsCursor == null) { LogUtil.w(TAG, "SyncCursorPair: Remote MMS query returned null cursor; " + "need to cancel sync"); throw new RuntimeException("Null cursor from remote MMS query"); } // Move to the first element in the combined stream from both cursors mNextSms = getSmsCursorNext(); mNextMms = getMmsCursorNext(); } catch (final SQLiteException e) { LogUtil.e(TAG, "SyncCursorPair: failed to query remote messages", e); // If we ignore this, the following code would think there is no remote message // and will delete all the local sms. We should be cautious here. So instead, // let's throw the exception to the caller and abort sms sync. We do the same // thing if either of the remote cursors is null. throw e; } } @Override public DatabaseMessage next() { DatabaseMessage result = null; if (mNextSms != null && mNextMms != null) { if (mNextSms.getTimestampInMillis() >= mNextMms.getTimestampInMillis()) { result = mNextSms; mNextSms = getSmsCursorNext(); } else { result = mNextMms; mNextMms = getMmsCursorNext(); } } else { if (mNextSms != null) { result = mNextSms; mNextSms = getSmsCursorNext(); } else { result = mNextMms; mNextMms = getMmsCursorNext(); } } return result; } private DatabaseMessage getSmsCursorNext() { if (mSmsCursor != null && mSmsCursor.moveToNext()) { return SmsMessage.get(mSmsCursor); } return null; } private DatabaseMessage getMmsCursorNext() { if (mMmsCursor != null && mMmsCursor.moveToNext()) { return MmsMessage.get(mMmsCursor); } return null; } @Override // Return approximate cursor position allowing for read ahead on two cursors (hence -1) public int getPosition() { return (mSmsCursor == null ? 0 : mSmsCursor.getPosition()) + (mMmsCursor == null ? 0 : mMmsCursor.getPosition()) - 1; } @Override public int getCount() { return (mSmsCursor == null ? 0 : mSmsCursor.getCount()) + (mMmsCursor == null ? 0 : mMmsCursor.getCount()); } @Override public void close() { if (mSmsCursor != null) { mSmsCursor.close(); mSmsCursor = null; } if (mMmsCursor != null) { mMmsCursor.close(); mMmsCursor = null; } } } /** * Type selection for importing sms messages. Only SENT and INBOX messages are imported. * * @return The SQL selection for importing sms messages */ public static String getSmsTypeSelectionSql() { return MmsUtils.getSmsTypeSelectionSql(); } /** * Type selection for importing mms messages. * * Criteria: * MESSAGE_BOX is INBOX, SENT or OUTBOX * MESSAGE_TYPE is SEND_REQ (sent), RETRIEVE_CONF (received) or NOTIFICATION_IND (download) * * @return The SQL selection for importing mms messages. This selects the message type, * not including the selection on timestamp. */ public static String getMmsTypeSelectionSql() { return MmsUtils.getMmsTypeSelectionSql(); } /** * Get a SQL selection string using an existing selection and time window limits * The limits are not applied if the value is < 0 * * @param typeSelection The existing selection * @param from The inclusive lower bound * @param to The exclusive upper bound * @return The created SQL selection */ private static String getTimeConstrainedQuery(final String typeSelection, final String timeColumn, final long from, final long to, final String threadColumn, final String threadId) { final StringBuilder queryBuilder = new StringBuilder(); queryBuilder.append(typeSelection); if (from > 0) { queryBuilder.append(" AND ").append(timeColumn).append(">=").append(from); } if (to > 0) { queryBuilder.append(" AND ").append(timeColumn).append("<").append(to); } if (!TextUtils.isEmpty(threadColumn) && !TextUtils.isEmpty(threadId)) { queryBuilder.append(" AND ").append(threadColumn).append("=").append(threadId); } return queryBuilder.toString(); } private static final String[] COUNT_PROJECTION = new String[] { "count()" }; private static int getCountFromCursor(final Cursor cursor) { if (cursor != null && cursor.moveToFirst()) { return cursor.getInt(0); } // We should only return a number if we were able to read it from the cursor. // Otherwise, we throw an exception to cancel the sync. String cursorDesc = ""; if (cursor == null) { cursorDesc = "null"; } else if (cursor.getCount() == 0) { cursorDesc = "empty"; } throw new IllegalArgumentException("Cannot get count from " + cursorDesc + " cursor"); } private void saveMessageToAdd(final List<SmsMessage> smsToAdd, final LongSparseArray<MmsMessage> mmsToAdd, final DatabaseMessage message, final ThreadInfoCache threadInfoCache) { long threadId; if (message.getProtocol() == MessageData.PROTOCOL_MMS) { final MmsMessage mms = (MmsMessage) message; mmsToAdd.append(mms.getId(), mms); threadId = mms.mThreadId; } else { final SmsMessage sms = (SmsMessage) message; smsToAdd.add(sms); threadId = sms.mThreadId; } // Cache the lookup and canonicalization of the phone number outside of the transaction... threadInfoCache.getThreadRecipients(threadId); } /** * Check if SMS has been synchronized. We compare the counts of messages on both * sides and return true if they are equal. * * Note that this may not be the most reliable way to tell if messages are in sync. * For example, the local misses one message and has one obsolete message. * However, we have background sms sync once a while, also some other events might * trigger a full sync. So we will eventually catch up. And this should be rare to * happen. * * @return If sms is in sync with telephony sms/mms providers */ private static boolean isSynchronized(final DatabaseWrapper db, final String localSelection, final String[] localSelectionArgs, final String smsSelection, final String[] smsSelectionArgs, final String mmsSelection, final String[] mmsSelectionArgs) { final Context context = Factory.get().getApplicationContext(); Cursor localCursor = null; Cursor remoteSmsCursor = null; Cursor remoteMmsCursor = null; try { localCursor = db.query(DatabaseHelper.MESSAGES_TABLE, COUNT_PROJECTION, localSelection, localSelectionArgs, null/*groupBy*/, null/*having*/, null/*orderBy*/); final int localCount = getCountFromCursor(localCursor); remoteSmsCursor = SqliteWrapper.query(context, context.getContentResolver(), Sms.CONTENT_URI, COUNT_PROJECTION, smsSelection, smsSelectionArgs, null/*orderBy*/); final int smsCount = getCountFromCursor(remoteSmsCursor); remoteMmsCursor = SqliteWrapper.query(context, context.getContentResolver(), Mms.CONTENT_URI, COUNT_PROJECTION, mmsSelection, mmsSelectionArgs, null/*orderBy*/); final int mmsCount = getCountFromCursor(remoteMmsCursor); final int remoteCount = smsCount + mmsCount; final boolean isInSync = (localCount == remoteCount); if (isInSync) { if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { LogUtil.d(TAG, "SyncCursorPair: Same # of local and remote messages = " + localCount); } } else { LogUtil.i(TAG, "SyncCursorPair: Not in sync; # local messages = " + localCount + ", # remote message = " + remoteCount); } return isInSync; } catch (final Exception e) { LogUtil.e(TAG, "SyncCursorPair: failed to query local or remote message counts", e); // If something is wrong in querying database, assume we are synced so // we don't retry indefinitely } finally { if (localCursor != null) { localCursor.close(); } if (remoteSmsCursor != null) { remoteSmsCursor.close(); } if (remoteMmsCursor != null) { remoteMmsCursor.close(); } } return true; } }