From f6e04d0f8963ebb45bc325de04360c3dc5d01c7b Mon Sep 17 00:00:00 2001 From: Jake McGinty Date: Thu, 24 Apr 2014 16:40:54 -0700 Subject: [PATCH] use latest android number as recipient number Fixes #791 // FREEBIE --- .../CanonicalAddressDatabaseTest.java | 118 ++++++++++++++++++ .../util/PhoneNumberFormatterTest.java | 33 +++++ .../thoughtcrime/securesms/util/UtilTest.java | 9 ++ build.gradle | 10 +- library/build.gradle | 2 +- .../securesms/ConversationListActivity.java | 20 ++- .../database/CanonicalAddressDatabase.java | 91 +++++++++----- .../database/CanonicalSessionMigrator.java | 2 +- .../securesms/database/ThreadDatabase.java | 2 +- .../securesms/recipients/Recipient.java | 5 +- .../recipients/RecipientFactory.java | 3 +- .../recipients/RecipientProvider.java | 21 ++-- .../securesms/util/VisibleForTesting.java | 4 + 13 files changed, 266 insertions(+), 54 deletions(-) create mode 100644 androidTest/org/thoughtcrime/securesms/database/CanonicalAddressDatabaseTest.java create mode 100644 androidTest/org/thoughtcrime/securesms/util/PhoneNumberFormatterTest.java create mode 100644 androidTest/org/thoughtcrime/securesms/util/UtilTest.java create mode 100644 src/org/thoughtcrime/securesms/util/VisibleForTesting.java diff --git a/androidTest/org/thoughtcrime/securesms/database/CanonicalAddressDatabaseTest.java b/androidTest/org/thoughtcrime/securesms/database/CanonicalAddressDatabaseTest.java new file mode 100644 index 0000000000..344c7fa0ca --- /dev/null +++ b/androidTest/org/thoughtcrime/securesms/database/CanonicalAddressDatabaseTest.java @@ -0,0 +1,118 @@ +package org.thoughtcrime.securesms.database; + +import android.test.InstrumentationTestCase; + +import static org.fest.assertions.api.Assertions.assertThat; + +public class CanonicalAddressDatabaseTest extends InstrumentationTestCase { + private static final String AMBIGUOUS_NUMBER = "222-3333"; + private static final String SPECIFIC_NUMBER = "+49 444 222 3333"; + private static final String EMAIL = "a@b.fom"; + private static final String SIMILAR_EMAIL = "a@b.com"; + private static final String GROUP = "__textsecure_group__!000111222333"; + private static final String SIMILAR_GROUP = "__textsecure_group__!100111222333"; + private static final String ALPHA = "T-Mobile"; + private static final String SIMILAR_ALPHA = "T-Mobila"; + + private CanonicalAddressDatabase db; + + public void setUp() throws Exception { + super.setUp(); + this.db = CanonicalAddressDatabase.getInstance(getInstrumentation().getTargetContext()); + } + + public void tearDown() throws Exception { + + } + + /** + * Throw two equivalent numbers (one without locale info, one with full info) at the canonical + * address db and see that the caching and DB operations work properly in revealing the right + * addresses. This is run twice to ensure cache logic is hit. + * + * @throws Exception + */ + public void testNumberAddressUpdates() throws Exception { + final long id = db.getCanonicalAddressId(AMBIGUOUS_NUMBER); + + assertThat(db.getAddressFromId(id)).isEqualTo(AMBIGUOUS_NUMBER); + assertThat(db.getCanonicalAddressId(SPECIFIC_NUMBER)).isEqualTo(id); + assertThat(db.getAddressFromId(id)).isEqualTo(SPECIFIC_NUMBER); + assertThat(db.getCanonicalAddressId(AMBIGUOUS_NUMBER)).isEqualTo(id); + + assertThat(db.getCanonicalAddressId(AMBIGUOUS_NUMBER)).isEqualTo(id); + assertThat(db.getAddressFromId(id)).isEqualTo(AMBIGUOUS_NUMBER); + assertThat(db.getCanonicalAddressId(SPECIFIC_NUMBER)).isEqualTo(id); + assertThat(db.getAddressFromId(id)).isEqualTo(SPECIFIC_NUMBER); + assertThat(db.getCanonicalAddressId(AMBIGUOUS_NUMBER)).isEqualTo(id); + } + + public void testSimilarNumbers() throws Exception { + assertThat(db.getCanonicalAddressId("This is a phone number 222-333-444")) + .isNotEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("222-333-444")) + .isNotEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("222-333-44")) + .isNotEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("222-333-4")) + .isNotEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("+49 222-333-4444")) + .isNotEqualTo(db.getCanonicalAddressId("+1 222-333-4444")); + + assertThat(db.getCanonicalAddressId("1 222-333-4444")) + .isEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("1 (222) 333-4444")) + .isEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("+12223334444")) + .isEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("+1 (222) 333.4444")) + .isEqualTo(db.getCanonicalAddressId("222-333-4444")); + assertThat(db.getCanonicalAddressId("+49 (222) 333.4444")) + .isEqualTo(db.getCanonicalAddressId("222-333-4444")); + + } + + public void testEmailAddresses() throws Exception { + final long emailId = db.getCanonicalAddressId(EMAIL); + final long similarEmailId = db.getCanonicalAddressId(SIMILAR_EMAIL); + + assertThat(emailId).isNotEqualTo(similarEmailId); + + assertThat(db.getAddressFromId(emailId)).isEqualTo(EMAIL); + assertThat(db.getAddressFromId(similarEmailId)).isEqualTo(SIMILAR_EMAIL); + } + + public void testGroups() throws Exception { + final long groupId = db.getCanonicalAddressId(GROUP); + final long similarGroupId = db.getCanonicalAddressId(SIMILAR_GROUP); + + assertThat(groupId).isNotEqualTo(similarGroupId); + + assertThat(db.getAddressFromId(groupId)).isEqualTo(GROUP); + assertThat(db.getAddressFromId(similarGroupId)).isEqualTo(SIMILAR_GROUP); + } + + public void testAlpha() throws Exception { + final long id = db.getCanonicalAddressId(ALPHA); + final long similarId = db.getCanonicalAddressId(SIMILAR_ALPHA); + + assertThat(id).isNotEqualTo(similarId); + + assertThat(db.getAddressFromId(id)).isEqualTo(ALPHA); + assertThat(db.getAddressFromId(similarId)).isEqualTo(SIMILAR_ALPHA); + } + + public void testIsNumber() throws Exception { + assertThat(CanonicalAddressDatabase.isNumberAddress("+495556666777")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("(222) 333-4444")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("1 (222) 333-4444")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("T-Mobile123")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("333-4444")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("12345")).isTrue(); + assertThat(CanonicalAddressDatabase.isNumberAddress("T-Mobile")).isFalse(); + assertThat(CanonicalAddressDatabase.isNumberAddress("T-Mobile1")).isFalse(); + assertThat(CanonicalAddressDatabase.isNumberAddress("Wherever bank")).isFalse(); + assertThat(CanonicalAddressDatabase.isNumberAddress("__textsecure_group__!afafafafafaf")).isFalse(); + assertThat(CanonicalAddressDatabase.isNumberAddress("email@domain.com")).isFalse(); + } +} \ No newline at end of file diff --git a/androidTest/org/thoughtcrime/securesms/util/PhoneNumberFormatterTest.java b/androidTest/org/thoughtcrime/securesms/util/PhoneNumberFormatterTest.java new file mode 100644 index 0000000000..ede681e891 --- /dev/null +++ b/androidTest/org/thoughtcrime/securesms/util/PhoneNumberFormatterTest.java @@ -0,0 +1,33 @@ +package org.thoughtcrime.securesms.util; + +import android.test.AndroidTestCase; + +import junit.framework.AssertionFailedError; + +import org.whispersystems.textsecure.util.InvalidNumberException; +import org.whispersystems.textsecure.util.PhoneNumberFormatter; +import static org.fest.assertions.api.Assertions.assertThat; + +public class PhoneNumberFormatterTest extends AndroidTestCase { + private static final String LOCAL_NUMBER = "+15555555555"; + + public void testFormatNumberE164() throws Exception, InvalidNumberException { + assertThat(PhoneNumberFormatter.formatNumber("(555) 555-5555", LOCAL_NUMBER)).isEqualTo(LOCAL_NUMBER); + assertThat(PhoneNumberFormatter.formatNumber("555-5555", LOCAL_NUMBER)).isEqualTo(LOCAL_NUMBER); + assertThat(PhoneNumberFormatter.formatNumber("(123) 555-5555", LOCAL_NUMBER)).isNotEqualTo(LOCAL_NUMBER); + } + + public void testFormatNumberEmail() throws Exception { + try { + PhoneNumberFormatter.formatNumber("person@domain.com", LOCAL_NUMBER); + throw new AssertionFailedError("should have thrown on email"); + } catch (InvalidNumberException ine) { + // success + } + } + + @Override + public void setUp() throws Exception { + super.setUp(); + } +} diff --git a/androidTest/org/thoughtcrime/securesms/util/UtilTest.java b/androidTest/org/thoughtcrime/securesms/util/UtilTest.java new file mode 100644 index 0000000000..79e8d3c58b --- /dev/null +++ b/androidTest/org/thoughtcrime/securesms/util/UtilTest.java @@ -0,0 +1,9 @@ +package org.thoughtcrime.securesms.util; + +import android.test.AndroidTestCase; + +import static org.fest.assertions.api.Assertions.assertThat; + +public class UtilTest extends AndroidTestCase { + +} \ No newline at end of file diff --git a/build.gradle b/build.gradle index e95ff592aa..bea8d39c4b 100644 --- a/build.gradle +++ b/build.gradle @@ -27,6 +27,8 @@ dependencies { compile 'com.google.android.gcm:gcm-client:1.0.2' compile 'se.emilsjolander:stickylistheaders:2.2.0' + androidTestCompile 'com.squareup:fest-android:1.0.8' + compile project(':library') } @@ -38,7 +40,7 @@ dependencyVerification { 'se.emilsjolander:stickylistheaders:89146b46c96fea0e40200474a2625cda10fe94891e4128f53cdb42375091b9b6', 'com.google.protobuf:protobuf-java:ad9769a22989e688a46af4d3accc348cc501ced22118033230542bc916e33f0b', 'com.madgag:sc-light-jdk15on:931f39d351429fb96c2f749e7ecb1a256a8ebbf5edca7995c9cc085b94d1841d', - 'com.googlecode.libphonenumber:libphonenumber:c2cffa5c2ccb8fd5fc4b432aa7d1ee27482860c9751035a25c8ffa2375274fcf', + 'com.googlecode.libphonenumber:libphonenumber:eba17eae81dd622ea89a00a3a8c025b2f25d342e0d9644c5b62e16f15687c3ab', 'org.whispersystems:gson:08f4f7498455d1539c9233e5aac18e9b1805815ef29221572996508eb512fe51', ] } @@ -63,6 +65,12 @@ android { res.srcDirs = ['res'] assets.srcDirs = ['assets'] } + androidTest { + java.srcDirs = ['androidTest'] + resources.srcDirs = ['androidTest'] + aidl.srcDirs = ['androidTest'] + renderscript.srcDirs = ['androidTest'] + } } } diff --git a/library/build.gradle b/library/build.gradle index 59ddc81a45..3c2ffbd4ef 100644 --- a/library/build.gradle +++ b/library/build.gradle @@ -21,7 +21,7 @@ repositories { dependencies { compile 'com.google.protobuf:protobuf-java:2.4.1' compile 'com.madgag:sc-light-jdk15on:1.47.0.2' - compile 'com.googlecode.libphonenumber:libphonenumber:5.3' + compile 'com.googlecode.libphonenumber:libphonenumber:6.1' compile 'org.whispersystems:gson:2.2.4' } diff --git a/src/org/thoughtcrime/securesms/ConversationListActivity.java b/src/org/thoughtcrime/securesms/ConversationListActivity.java index cf95f92efc..29a0ae2e11 100644 --- a/src/org/thoughtcrime/securesms/ConversationListActivity.java +++ b/src/org/thoughtcrime/securesms/ConversationListActivity.java @@ -50,10 +50,11 @@ public class ConversationListActivity extends PassphraseRequiredSherlockFragment private final DynamicLanguage dynamicLanguage = new DynamicLanguage(); private ConversationListFragment fragment; - private MasterSecret masterSecret; - private DrawerLayout drawerLayout; - private DrawerToggle drawerToggle; - private ListView drawerList; + private MasterSecret masterSecret; + private DrawerLayout drawerLayout; + private DrawerToggle drawerToggle; + private ListView drawerList; + private ContentObserver observer; @Override public void onCreate(Bundle icicle) { @@ -92,6 +93,7 @@ public class ConversationListActivity extends PassphraseRequiredSherlockFragment public void onDestroy() { Log.w("ConversationListActivity", "onDestroy..."); MemoryCleaner.clean(masterSecret); + if (observer != null) getContentResolver().unregisterContentObserver(observer); super.onDestroy(); } @@ -254,11 +256,19 @@ public class ConversationListActivity extends PassphraseRequiredSherlockFragment } private void initializeContactUpdatesReceiver() { - ContentObserver observer = new ContentObserver(null) { + observer = new ContentObserver(null) { @Override public void onChange(boolean selfChange) { super.onChange(selfChange); + Log.w("ConversationListActivity", "detected android contact data changed, refreshing cache"); + // TODO only clear updated recipients from cache RecipientFactory.clearCache(); + ConversationListActivity.this.runOnUiThread(new Runnable() { + @Override + public void run() { + ((ConversationListAdapter)fragment.getListAdapter()).notifyDataSetChanged(); + } + }); } }; diff --git a/src/org/thoughtcrime/securesms/database/CanonicalAddressDatabase.java b/src/org/thoughtcrime/securesms/database/CanonicalAddressDatabase.java index 77d3854503..eadc51309e 100644 --- a/src/org/thoughtcrime/securesms/database/CanonicalAddressDatabase.java +++ b/src/org/thoughtcrime/securesms/database/CanonicalAddressDatabase.java @@ -22,13 +22,17 @@ import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.database.sqlite.SQLiteOpenHelper; +import android.telephony.PhoneNumberUtils; import android.util.Log; -import java.util.Collections; -import java.util.HashMap; +import org.thoughtcrime.securesms.util.GroupUtil; +import org.thoughtcrime.securesms.util.VisibleForTesting; +import org.whispersystems.textsecure.util.Util; + import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; public class CanonicalAddressDatabase { @@ -39,15 +43,15 @@ public class CanonicalAddressDatabase { private static final String ADDRESS_COLUMN = "address"; private static final String DATABASE_CREATE = "CREATE TABLE " + TABLE + " (" + ID_COLUMN + " integer PRIMARY KEY, " + ADDRESS_COLUMN + " TEXT NOT NULL);"; - private static final String[] ID_PROJECTION = {ID_COLUMN}; - private static final String SELECTION = "PHONE_NUMBERS_EQUAL(" + ADDRESS_COLUMN + ", ?)"; + private static final String SELECTION_NUMBER = "PHONE_NUMBERS_EQUAL(" + ADDRESS_COLUMN + ", ?)"; + private static final String SELECTION_OTHER = ADDRESS_COLUMN + " = ? COLLATE NOCASE"; private static final Object lock = new Object(); private static CanonicalAddressDatabase instance; - private DatabaseHelper databaseHelper; + private DatabaseHelper databaseHelper; - private final Map addressCache = Collections.synchronizedMap(new HashMap()); - private final Map idCache = Collections.synchronizedMap(new HashMap()); + private final Map addressCache = new ConcurrentHashMap(); + private final Map idCache = new ConcurrentHashMap(); public static CanonicalAddressDatabase getInstance(Context context) { synchronized (lock) { @@ -78,13 +82,13 @@ public class CanonicalAddressDatabase { cursor = db.query(TABLE, null, null, null, null, null, null); while (cursor != null && cursor.moveToNext()) { - long id = cursor.getLong(cursor.getColumnIndexOrThrow(ID_COLUMN)); + long id = cursor.getLong(cursor.getColumnIndexOrThrow(ID_COLUMN)); String address = cursor.getString(cursor.getColumnIndexOrThrow(ADDRESS_COLUMN)); if (address == null || address.trim().length() == 0) address = "Anonymous"; - idCache.put(id+"", address); + idCache.put(id, address); addressCache.put(address, id); } } finally { @@ -93,9 +97,7 @@ public class CanonicalAddressDatabase { } } - public String getAddressFromId(String id) { - if (id == null || id.trim().equals("")) return "Anonymous"; - + public String getAddressFromId(long id) { String cachedAddress = idCache.get(id); if (cachedAddress != null) @@ -131,58 +133,83 @@ public class CanonicalAddressDatabase { instance = null; } - public long getCanonicalAddress(String address) { - long canonicalAddress; + public long getCanonicalAddressId(String address) { + long canonicalAddressId; - if ((canonicalAddress = getCanonicalAddressFromCache(address)) != -1) - return canonicalAddress; + if ((canonicalAddressId = getCanonicalAddressFromCache(address)) != -1) + return canonicalAddressId; - canonicalAddress = getCanonicalAddressFromDatabase(address); - addressCache.put(address, canonicalAddress); - - return canonicalAddress; + canonicalAddressId = getCanonicalAddressIdFromDatabase(address); + idCache.put(canonicalAddressId, address); + addressCache.put(address, canonicalAddressId); + return canonicalAddressId; } - public List getCanonicalAddresses(List addresses) { + public List getCanonicalAddressIds(List addresses) { List addressList = new LinkedList(); for (String address : addresses) { - addressList.add(getCanonicalAddress(address)); + addressList.add(getCanonicalAddressId(address)); } return addressList; } private long getCanonicalAddressFromCache(String address) { - if (addressCache.containsKey(address)) - return Long.valueOf(addressCache.get(address)); - - return -1L; + Long cachedAddress = addressCache.get(address); + return cachedAddress == null ? -1L : cachedAddress; } - private long getCanonicalAddressFromDatabase(String address) { + private long getCanonicalAddressIdFromDatabase(String address) { Cursor cursor = null; try { SQLiteDatabase db = databaseHelper.getWritableDatabase(); String[] selectionArguments = new String[] {address}; - cursor = db.query(TABLE, ID_PROJECTION, SELECTION, selectionArguments, null, null, null); + boolean isNumber = isNumberAddress(address); + cursor = db.query(TABLE, null, + isNumber ? SELECTION_NUMBER : SELECTION_OTHER, + selectionArguments, null, null, null); if (cursor.getCount() == 0 || !cursor.moveToFirst()) { ContentValues contentValues = new ContentValues(1); contentValues.put(ADDRESS_COLUMN, address); - return db.insert(TABLE, ADDRESS_COLUMN, contentValues); - } + } else { + final long canonicalId = cursor.getLong(cursor.getColumnIndexOrThrow(ID_COLUMN)); + final String oldAddress = cursor.getString(cursor.getColumnIndexOrThrow(ADDRESS_COLUMN)); + if (oldAddress == null || !oldAddress.equals(address)) { + ContentValues contentValues = new ContentValues(1); + contentValues.put(ADDRESS_COLUMN, address); + db.update(TABLE, contentValues, ID_COLUMN + " = ?", new String[]{canonicalId+""}); - return cursor.getLong(cursor.getColumnIndexOrThrow(ID_COLUMN)); + addressCache.remove(oldAddress); + } + return canonicalId; + } } finally { if (cursor != null) { cursor.close(); } } - } + @VisibleForTesting + static boolean isNumberAddress(String number) { + if (number.contains("@")) + return false; + if (GroupUtil.isEncodedGroup(number)) + return false; + + final String networkNumber = PhoneNumberUtils.extractNetworkPortion(number); + if (Util.isEmpty(networkNumber)) + return false; + if (networkNumber.length() < 3) + return false; + + return PhoneNumberUtils.isWellFormedSmsAddress(number); + } + + private static class DatabaseHelper extends SQLiteOpenHelper { public DatabaseHelper(Context context, String name, CursorFactory factory, int version) { diff --git a/src/org/thoughtcrime/securesms/database/CanonicalSessionMigrator.java b/src/org/thoughtcrime/securesms/database/CanonicalSessionMigrator.java index 44375a63a9..587ca26546 100644 --- a/src/org/thoughtcrime/securesms/database/CanonicalSessionMigrator.java +++ b/src/org/thoughtcrime/securesms/database/CanonicalSessionMigrator.java @@ -59,7 +59,7 @@ public class CanonicalSessionMigrator { File item = new File(rootDirectory.getAbsolutePath() + File.separatorChar + files[i]); if (!item.isDirectory() && files[i].matches("[0-9]+")) { - long canonicalAddress = canonicalDb.getCanonicalAddress(files[i]); + long canonicalAddress = canonicalDb.getCanonicalAddressId(files[i]); migrateSession(item, sessionsDirectory, canonicalAddress); } } diff --git a/src/org/thoughtcrime/securesms/database/ThreadDatabase.java b/src/org/thoughtcrime/securesms/database/ThreadDatabase.java index 933a6c13b1..8d5a1ac78b 100644 --- a/src/org/thoughtcrime/securesms/database/ThreadDatabase.java +++ b/src/org/thoughtcrime/securesms/database/ThreadDatabase.java @@ -248,7 +248,7 @@ public class ThreadDatabase extends Database { if (filter == null || filter.size() == 0) return null; - List recipientIds = DatabaseFactory.getAddressDatabase(context).getCanonicalAddresses(filter); + List recipientIds = DatabaseFactory.getAddressDatabase(context).getCanonicalAddressIds(filter); if (recipientIds == null || recipientIds.size() == 0) return null; diff --git a/src/org/thoughtcrime/securesms/recipients/Recipient.java b/src/org/thoughtcrime/securesms/recipients/Recipient.java index 6598102a84..7b8cf05ced 100644 --- a/src/org/thoughtcrime/securesms/recipients/Recipient.java +++ b/src/org/thoughtcrime/securesms/recipients/Recipient.java @@ -49,9 +49,9 @@ public class Recipient implements Parcelable, CanonicalRecipient { private final HashSet listeners = new HashSet(); - private final String number; - private final long recipientId; + private final long recipientId; + private String number; private String name; private Bitmap contactPhoto; @@ -75,6 +75,7 @@ public class Recipient implements Parcelable, CanonicalRecipient { synchronized (Recipient.this) { Recipient.this.name = result.name; + Recipient.this.number = result.number; Recipient.this.contactUri = result.contactUri; Recipient.this.contactPhoto = result.avatar; Recipient.this.circleCroppedContactPhoto = result.croppedAvatar; diff --git a/src/org/thoughtcrime/securesms/recipients/RecipientFactory.java b/src/org/thoughtcrime/securesms/recipients/RecipientFactory.java index 0ed8f4aec5..c577e11860 100644 --- a/src/org/thoughtcrime/securesms/recipients/RecipientFactory.java +++ b/src/org/thoughtcrime/securesms/recipients/RecipientFactory.java @@ -21,7 +21,6 @@ import android.util.Log; import org.thoughtcrime.securesms.contacts.ContactPhotoFactory; import org.thoughtcrime.securesms.database.CanonicalAddressDatabase; -import org.thoughtcrime.securesms.util.NumberUtil; import org.whispersystems.textsecure.push.IncomingPushMessage; import org.whispersystems.textsecure.util.Util; @@ -51,7 +50,7 @@ public class RecipientFactory { } private static Recipient getRecipientForNumber(Context context, String number, boolean asynchronous) { - long recipientId = CanonicalAddressDatabase.getInstance(context).getCanonicalAddress(number); + long recipientId = CanonicalAddressDatabase.getInstance(context).getCanonicalAddressId(number); return provider.getRecipient(context, recipientId, asynchronous); } diff --git a/src/org/thoughtcrime/securesms/recipients/RecipientProvider.java b/src/org/thoughtcrime/securesms/recipients/RecipientProvider.java index c075348893..f72aa4e43f 100644 --- a/src/org/thoughtcrime/securesms/recipients/RecipientProvider.java +++ b/src/org/thoughtcrime/securesms/recipients/RecipientProvider.java @@ -17,6 +17,7 @@ package org.thoughtcrime.securesms.recipients; import android.content.Context; +import android.database.ContentObserver; import android.database.Cursor; import android.graphics.Bitmap; import android.graphics.BitmapFactory; @@ -50,6 +51,7 @@ public class RecipientProvider { PhoneLookup.DISPLAY_NAME, PhoneLookup.LOOKUP_KEY, PhoneLookup._ID, + PhoneLookup.NUMBER }; public Recipient getRecipient(Context context, long recipientId, boolean asynchronous) { @@ -60,19 +62,19 @@ public class RecipientProvider { else return getSynchronousRecipient(context, recipientId); } - private Recipient getSynchronousRecipient(Context context, long recipientId) { + private Recipient getSynchronousRecipient(final Context context, final long recipientId) { Log.w("RecipientProvider", "Cache miss [SYNC]!"); - Recipient recipient; + final Recipient recipient; RecipientDetails details; - String number = CanonicalAddressDatabase.getInstance(context).getAddressFromId(String.valueOf(recipientId)); + String number = CanonicalAddressDatabase.getInstance(context).getAddressFromId(recipientId); final boolean isGroupRecipient = GroupUtil.isEncodedGroup(number); if (isGroupRecipient) details = getGroupRecipientDetails(context, number); else details = getRecipientDetails(context, number); if (details != null) { - recipient = new Recipient(details.name, number, recipientId, details.contactUri, details.avatar, + recipient = new Recipient(details.name, details.number, recipientId, details.contactUri, details.avatar, details.croppedAvatar); } else { final Bitmap defaultPhoto = isGroupRecipient @@ -92,7 +94,7 @@ public class RecipientProvider { private Recipient getAsynchronousRecipient(final Context context, final long recipientId) { Log.w("RecipientProvider", "Cache miss [ASYNC]!"); - final String number = CanonicalAddressDatabase.getInstance(context).getAddressFromId(String.valueOf(recipientId)); + final String number = CanonicalAddressDatabase.getInstance(context).getAddressFromId(recipientId); final boolean isGroupRecipient = GroupUtil.isEncodedGroup(number); Callable task = new Callable() { @@ -143,8 +145,7 @@ public class RecipientProvider { Uri contactUri = Contacts.getLookupUri(cursor.getLong(2), cursor.getString(1)); Bitmap contactPhoto = ContactPhotoFactory.getContactPhoto(context, Uri.withAppendedPath(Contacts.CONTENT_URI, cursor.getLong(2)+"")); - - return new RecipientDetails(cursor.getString(0), contactUri, contactPhoto, + return new RecipientDetails(cursor.getString(0), cursor.getString(3), contactUri, contactPhoto, BitmapUtil.getCircleCroppedBitmap(contactPhoto)); } } finally { @@ -167,7 +168,7 @@ public class RecipientProvider { if (avatarBytes == null) avatar = ContactPhotoFactory.getDefaultGroupPhoto(context); else avatar = BitmapFactory.decodeByteArray(avatarBytes, 0, avatarBytes.length); - return new RecipientDetails(record.getTitle(), null, avatar, BitmapUtil.getCircleCroppedBitmap(avatar)); + return new RecipientDetails(record.getTitle(), groupId, null, avatar, BitmapUtil.getCircleCroppedBitmap(avatar)); } return null; @@ -179,12 +180,14 @@ public class RecipientProvider { public static class RecipientDetails { public final String name; + public final String number; public final Bitmap avatar; public final Bitmap croppedAvatar; public final Uri contactUri; - public RecipientDetails(String name, Uri contactUri, Bitmap avatar, Bitmap croppedAvatar) { + public RecipientDetails(String name, String number, Uri contactUri, Bitmap avatar, Bitmap croppedAvatar) { this.name = name; + this.number = number; this.avatar = avatar; this.croppedAvatar = croppedAvatar; this.contactUri = contactUri; diff --git a/src/org/thoughtcrime/securesms/util/VisibleForTesting.java b/src/org/thoughtcrime/securesms/util/VisibleForTesting.java new file mode 100644 index 0000000000..3a8a9d7b5f --- /dev/null +++ b/src/org/thoughtcrime/securesms/util/VisibleForTesting.java @@ -0,0 +1,4 @@ +package org.thoughtcrime.securesms.util; + +public @interface VisibleForTesting { +}