Allow smart dialing to ignore country code/area code

Add handling of country codes if the number starts with a '+' prefix
Also add special case handling for NANP numbers in SmartDialTrie
if we determine that the user is in North America.
Save user's SIM country ISO into SharedPreferences.
Add SmartDialNameMatcher methods to correctly match NANP numbers
Fix tests to use assertTrue/assertFalse instead of assertEquals

Bug 8292294
Change-Id: Ic61dac75ee3b772986d3008240bbda81322c8f31

3 files changed, 264 insertions, 35 deletions

diff --git a/tests/src/com/android/dialer/dialpad/SmartDialCacheTest.java b/tests/src/com/android/dialer/dialpad/SmartDialCacheTest.java
new file mode 100644
index 000000000..8d96edafc
--- /dev/null
+++ b/tests/src/com/android/dialer/dialpad/SmartDialCacheTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2013 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.dialer.dialpad;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import junit.framework.TestCase;
+
+@SmallTest
+public class SmartDialCacheTest extends TestCase {
+    public void testIsCountryNanp_CaseInsensitive() {
+        assertFalse(SmartDialCache.isCountryNanp(null));
+        assertFalse(SmartDialCache.isCountryNanp("CN"));
+        assertFalse(SmartDialCache.isCountryNanp("HK"));
+        assertFalse(SmartDialCache.isCountryNanp("uk"));
+        assertFalse(SmartDialCache.isCountryNanp("sg"));
+        assertTrue(SmartDialCache.isCountryNanp("US"));
+        assertTrue(SmartDialCache.isCountryNanp("CA"));
+        assertTrue(SmartDialCache.isCountryNanp("AS"));
+        assertTrue(SmartDialCache.isCountryNanp("AI"));
+        assertTrue(SmartDialCache.isCountryNanp("AG"));
+        assertTrue(SmartDialCache.isCountryNanp("BS"));
+        assertTrue(SmartDialCache.isCountryNanp("BB"));
+        assertTrue(SmartDialCache.isCountryNanp("bm"));
+        assertTrue(SmartDialCache.isCountryNanp("vg"));
+        assertTrue(SmartDialCache.isCountryNanp("ky"));
+        assertTrue(SmartDialCache.isCountryNanp("dm"));
+        assertTrue(SmartDialCache.isCountryNanp("do"));
+        assertTrue(SmartDialCache.isCountryNanp("gd"));
+        assertTrue(SmartDialCache.isCountryNanp("gu"));
+        assertTrue(SmartDialCache.isCountryNanp("jm"));
+        assertTrue(SmartDialCache.isCountryNanp("pr"));
+        assertTrue(SmartDialCache.isCountryNanp("ms"));
+        assertTrue(SmartDialCache.isCountryNanp("mp"));
+        assertTrue(SmartDialCache.isCountryNanp("kn"));
+        assertTrue(SmartDialCache.isCountryNanp("lc"));
+        assertTrue(SmartDialCache.isCountryNanp("vc"));
+        assertTrue(SmartDialCache.isCountryNanp("tt"));
+        assertTrue(SmartDialCache.isCountryNanp("tc"));
+        assertTrue(SmartDialCache.isCountryNanp("vi"));
+    }
+}
diff --git a/tests/src/com/android/dialer/dialpad/SmartDialNameMatcherTest.java b/tests/src/com/android/dialer/dialpad/SmartDialNameMatcherTest.java
index 08939b48e..3c481d0c7 100644
--- a/tests/src/com/android/dialer/dialpad/SmartDialNameMatcherTest.java
+++ b/tests/src/com/android/dialer/dialpad/SmartDialNameMatcherTest.java
@@ -91,6 +91,8 @@ public class SmartDialNameMatcherTest extends TestCase {
         checkMatches("William John-Smith", "5764", true, 8, 9, 13, 16);
         // make sure multiple spaces don't mess things up
         checkMatches("William        John---Smith", "5764", true, 15, 16, 22, 25);
+
+        checkMatches("Berkeley Hair-Studio", "788346", true, 14, 20);
     }
 
     public void testMatches_repeatedSeparators() {
@@ -114,6 +116,7 @@ public class SmartDialNameMatcherTest extends TestCase {
     public void testMatches_umlaut() {
         checkMatches("ÄÖÜäöü", "268268", true, 0, 6);
     }
+
     // TODO: Great if it was treated as "s" or "ss. Figure out if possible without prefix trie?
     @Suppress
     public void testMatches_germanSharpS() {
@@ -135,6 +138,80 @@ public class SmartDialNameMatcherTest extends TestCase {
         fail("Cyrillic letters aren't supported yet.");
     }
 
+
+    public void testMatches_NumberBasic() {
+        // Simple basic examples that start the match from the start of the number
+        checkMatchesNumber("5103337596", "510", true, 0, 3);
+        checkMatchesNumber("5103337596", "511", false, 0, 0);
+        checkMatchesNumber("5103337596", "5103337596", true, 0, 10);
+        checkMatchesNumber("123-456-789", "123456789", true, 0, 11);
+        checkMatchesNumber("123-456-789", "123456788", false, 0, 0);
+        checkMatchesNumber("09999999999", "099", true, 0, 3);
+    }
+
+    public void testMatches_NumberWithCountryCode() {
+        // These matches should ignore the country prefix
+        // USA (+1)
+        checkMatchesNumber("+15103337596", "5103337596", true, 2, 12);
+        checkMatchesNumber("+15103337596", "15103337596", true, 0, 12);
+
+        // Singapore (+65)
+        checkMatchesNumber("+6591776930", "6591", true, 0, 5);
+        checkMatchesNumber("+6591776930", "9177", true, 3, 7);
+        checkMatchesNumber("+6591776930", "5917", false, 3, 7);
+
+        // Hungary (+36)
+        checkMatchesNumber("+3612345678", "361234", true, 0, 7);
+        checkMatchesNumber("+3612345678", "1234", true, 3, 7);
+
+        // Hongkong (+852)
+        checkMatchesNumber("+852 2222 2222", "85222222222", true, 0, 14);
+        checkMatchesNumber("+852 2222 3333", "2222", true, 5, 9);
+
+        // Invalid (+854)
+        checkMatchesNumber("+854 1111 2222", "8541111", true, 0, 9);
+        checkMatchesNumber("+854 1111 2222", "1111", false, 0, 0);
+    }
+
+    public void testMatches_NumberNANP() {
+        // An 11 digit number prefixed with 1 should be matched by the 10 digit number, as well as
+        // the 7 digit number (without area code)
+        checkMatchesNumber("1-510-333-7596", "5103337596", true, true, 2, 14);
+        checkMatchesNumber("1-510-333-7596", "3337596", true, true, 6, 14);
+
+        // Invalid NANP numbers should not be matched
+        checkMatchesNumber("1-510-333-759", "510333759", false, true, 0, 0);
+        checkMatchesNumber("510-333-759", "333759", false, true, 0, 0);
+
+        // match should fail if NANP flag is switched off
+        checkMatchesNumber("1-510-333-7596", "3337596", false, false, 0, 0);
+
+        // A 10 digit number without a 1 prefix should be matched by the 7 digit number
+        checkMatchesNumber("(650) 292 2323", "2922323", true, true, 6, 14);
+        checkMatchesNumber("(650) 292 2323", "6502922323", true, true, 0, 14);
+        // match should fail if NANP flag is switched off
+        checkMatchesNumber("(650) 292 2323", "2922323", false, false, 0, 0);
+        // But this should still match (since it is the full number)
+        checkMatchesNumber("(650) 292 2323", "6502922323", true, false, 0, 14);
+    }
+
+
+    private void checkMatchesNumber(String number, String query, boolean expectedMatches,
+            int matchStart, int matchEnd) {
+        checkMatchesNumber(number, query, expectedMatches, false, matchStart, matchEnd);
+    }
+
+    private void checkMatchesNumber(String number, String query, boolean expectedMatches,
+            boolean matchNanp, int matchStart, int matchEnd) {
+        final SmartDialMatchPosition pos = SmartDialNameMatcher.matchesNumber(number, query,
+                matchNanp);
+        assertEquals(expectedMatches, pos != null);
+        if (expectedMatches) {
+            assertEquals("start", matchStart, pos.start);
+            assertEquals("end", matchEnd, pos.end);
+        }
+    }
+
     private void checkMatches(String displayName, String query, boolean expectedMatches,
             int... expectedMatchPositions) {
         final SmartDialNameMatcher matcher = new SmartDialNameMatcher(query);
diff --git a/tests/src/com/android/dialer/dialpad/SmartDialTrieTest.java b/tests/src/com/android/dialer/dialpad/SmartDialTrieTest.java
index 0378555d0..7f55263e1 100644
--- a/tests/src/com/android/dialer/dialpad/SmartDialTrieTest.java
+++ b/tests/src/com/android/dialer/dialpad/SmartDialTrieTest.java
@@ -48,11 +48,11 @@ public class SmartDialTrieTest extends TestCase{
         final ContactNumber jasonsmitt = new ContactNumber(1, "Jason Smitt", "0", "1", 2);
         trie.put(jasonsmith);
         trie.put(jasonsmitt);
-        assertEquals(true, trie.getAllWithPrefix("5276676484").contains(jasonsmith));
-        assertEquals(false, trie.getAllWithPrefix("5276676484").contains(jasonsmitt));
+        assertTrue(trie.getAllWithPrefix("5276676484").contains(jasonsmith));
+        assertFalse(trie.getAllWithPrefix("5276676484").contains(jasonsmitt));
 
-        assertEquals(false, trie.getAllWithPrefix("5276676488").contains(jasonsmith));
-        assertEquals(true, trie.getAllWithPrefix("5276676488").contains(jasonsmitt));
+        assertFalse(trie.getAllWithPrefix("5276676488").contains(jasonsmith));
+        assertTrue(trie.getAllWithPrefix("5276676488").contains(jasonsmitt));
 
     }
 
@@ -66,18 +66,18 @@ public class SmartDialTrieTest extends TestCase{
         trie.put(jasonsmitt);
 
         // 6279 corresponds to mary = "Mary Jane" but not "Jason Smitt"
-        assertEquals(true, checkContains(trie, maryjane, "6279"));
-        assertEquals(false, checkContains(trie, jasonsmitt, "6279"));
+        assertTrue(checkContains(trie, maryjane, "6279"));
+        assertFalse(checkContains(trie, jasonsmitt, "6279"));
 
         // 72 corresponds to sa = "Sarah Smith" but not "Jason Smitt" or "Mary Jane"
-        assertEquals(false, checkContains(trie, maryjane, "72"));
-        assertEquals(true, checkContains(trie, sarahsmith, "72"));
-        assertEquals(false, checkContains(trie, jasonsmitt, "72"));
+        assertFalse(checkContains(trie, maryjane, "72"));
+        assertTrue(checkContains(trie, sarahsmith, "72"));
+        assertFalse(checkContains(trie, jasonsmitt, "72"));
 
         // 76 corresponds to sm = "Sarah Smith" and "Jason Smitt" but not "Mary Jane"
-        assertEquals(false, checkContains(trie, maryjane, "76"));
-        assertEquals(true, checkContains(trie, sarahsmith, "76"));
-        assertEquals(true, checkContains(trie, jasonsmitt, "76"));
+        assertFalse(checkContains(trie, maryjane, "76"));
+        assertTrue(checkContains(trie, sarahsmith, "76"));
+        assertTrue(checkContains(trie, jasonsmitt, "76"));
     }
 
     public void testPutForNameTokens() {
@@ -86,11 +86,11 @@ public class SmartDialTrieTest extends TestCase{
         trie.put(jasonfwilliams);
 
         // 527 corresponds to jas = "Jason"
-        assertEquals(true, checkContains(trie, jasonfwilliams, "527"));
+        assertTrue(checkContains(trie, jasonfwilliams, "527"));
         // 945 corresponds to wil = "Wil"
-        assertEquals(true, checkContains(trie, jasonfwilliams, "945"));
+        assertTrue(checkContains(trie, jasonfwilliams, "945"));
         // 66 doesn't match
-        assertEquals(false, checkContains(trie, jasonfwilliams, "66"));
+        assertFalse(checkContains(trie, jasonfwilliams, "66"));
     }
 
     public void testPutForInitialMatches() {
@@ -99,21 +99,21 @@ public class SmartDialTrieTest extends TestCase{
                 new ContactNumber(0, "Martin Jr Harry", "0", "0", 1);
         trie.put(martinjuniorharry);
         // 654 corresponds to mjh = "(M)artin (J)r (H)arry"
-        assertEquals(true, checkContains(trie, martinjuniorharry, "654"));
+        assertTrue(checkContains(trie, martinjuniorharry, "654"));
         // The reverse (456) does not match (for now)
-        assertEquals(false, checkContains(trie, martinjuniorharry, "456"));
+        assertFalse(checkContains(trie, martinjuniorharry, "456"));
         // 6542 corresponds to mjha = "(M)artin (J)r (Ha)rry"
-        assertEquals(true, checkContains(trie, martinjuniorharry, "6542"));
+        assertTrue(checkContains(trie, martinjuniorharry, "6542"));
         // 542 corresponds to jha = "Martin (J)r (Ha)rry"
-        assertEquals(true, checkContains(trie, martinjuniorharry, "542"));
+        assertTrue(checkContains(trie, martinjuniorharry, "542"));
         // 547 doesn't match
-        assertEquals(false, checkContains(trie, martinjuniorharry, "547"));
+        assertFalse(checkContains(trie, martinjuniorharry, "547"));
         // 655 doesn't match
-        assertEquals(false, checkContains(trie, martinjuniorharry, "655"));
+        assertFalse(checkContains(trie, martinjuniorharry, "655"));
         // 653 doesn't match
-        assertEquals(false, checkContains(trie, martinjuniorharry, "653"));
+        assertFalse(checkContains(trie, martinjuniorharry, "653"));
         // 6543 doesn't match
-        assertEquals(false, checkContains(trie, martinjuniorharry, "6543"));
+        assertFalse(checkContains(trie, martinjuniorharry, "6543"));
     }
 
     public void testSeparators() {
@@ -124,9 +124,9 @@ public class SmartDialTrieTest extends TestCase{
         for (int i = 0; i < name.length(); i++) {
             // separators at position 8 and 12
             if (i == 8 || i == 14) {
-                assertEquals(true, bytes[i] == -1);
+                assertTrue(bytes[i] == -1);
             } else {
-                assertEquals(false, bytes[i] == -1);
+                assertFalse(bytes[i] == -1);
             }
         }
     }
@@ -137,8 +137,8 @@ public class SmartDialTrieTest extends TestCase{
         final ContactNumber bronte = new ContactNumber(2, "Brontë", "0", "1", 2);
         trie.put(reenee);
         trie.put(bronte);
-        assertEquals(true, checkContains(trie, reenee, "733633"));
-        assertEquals(true, checkContains(trie, bronte, "276683"));
+        assertTrue(checkContains(trie, reenee, "733633"));
+        assertTrue(checkContains(trie, bronte, "276683"));
     }
 
     public void testPutForNumbers() {
@@ -150,15 +150,111 @@ public class SmartDialTrieTest extends TestCase{
         final ContactNumber contactno3 = new ContactNumber(0, "James", "+13684976334", "0", 1);
         trie.put(contactno3);
         // all phone numbers belonging to the contact should correspond to it
-        assertEquals(true, checkContains(trie, contactno1, "510"));
-        assertEquals(false, checkContains(trie, contactno1, "511"));
-        assertEquals(true, checkContains(trie, contactno2, "77212862357"));
-        assertEquals(false, checkContains(trie, contactno2, "77212862356"));
-        assertEquals(true, checkContains(trie, contactno3, "1368"));
-        assertEquals(false, checkContains(trie, contactno3, "1367"));
+        assertTrue(checkContains(trie, contactno1, "510"));
+        assertFalse(checkContains(trie, contactno1, "511"));
+        assertTrue(checkContains(trie, contactno2, "77212862357"));
+        assertFalse(checkContains(trie, contactno2, "77212862356"));
+        assertTrue(checkContains(trie, contactno3, "1368"));
+        assertFalse(checkContains(trie, contactno3, "1367"));
 
     }
 
+    public void testPutNumbersCountryCode() {
+        final SmartDialTrie trie = new SmartDialTrie();
+        final ContactNumber contactno1 = new ContactNumber(0, "James", "+13684976334", "0", 1);
+        trie.put(contactno1);
+
+        // all phone numbers belonging to the contact should correspond to it
+        assertTrue(checkContains(trie, contactno1, "1368"));
+        assertTrue(checkContains(trie, contactno1, "368497"));
+        assertFalse(checkContains(trie, contactno1, "2368497"));
+
+        final ContactNumber contactno2 = new ContactNumber(0, "Jason", "+65 9177-6930", "0", 1);
+        trie.put(contactno2);
+
+        assertTrue(checkContains(trie, contactno2, "6591776930"));
+        assertTrue(checkContains(trie, contactno2, "91776930"));
+        assertFalse(checkContains(trie, contactno2, "591776930"));
+
+        final ContactNumber contactno3 = new ContactNumber(0, "Mike", "+85212345678", "0", 1);
+        trie.put(contactno3);
+        assertTrue(checkContains(trie, contactno3, "85212345678"));
+        assertTrue(checkContains(trie, contactno3, "12345678"));
+        assertFalse(checkContains(trie, contactno2, "5212345678"));
+
+        // Invalid country code, don't try to parse it
+        final ContactNumber contactno4 = new ContactNumber(0, "Invalid", "+85112345678", "0", 1);
+        trie.put(contactno4);
+        assertTrue(checkContains(trie, contactno4, "85112345678"));
+        assertFalse(checkContains(trie, contactno4, "12345678"));
+
+        final ContactNumber contactno5 = new ContactNumber(0, "Invalid", "+852", "0", 1);
+        // Shouldn't crash
+        trie.put(contactno5);
+    }
+
+    // Tests special case handling for NANP numbers
+    public void testPutNumbersNANP() {
+
+        final SmartDialTrie trie = new SmartDialTrie(true /* formatNanp */);
+        // Unformatted number with 1 prefix
+        final ContactNumber contactno1 = new ContactNumber(0, "James", "16503337596", "0", 1);
+        trie.put(contactno1);
+
+        assertTrue(checkContains(trie, contactno1, "16503337596"));
+        assertTrue(checkContains(trie, contactno1, "6503337596"));
+        assertTrue(checkContains(trie, contactno1, "3337596"));
+
+        // Number with seperators
+        final ContactNumber contactno2 = new ContactNumber(0, "Michael", "5109921234", "0", 1);
+        trie.put(contactno2);
+        assertTrue(checkContains(trie, contactno2, "5109921234"));
+        assertTrue(checkContains(trie, contactno2, "9921234"));
+
+        // Number with area code only + separators
+        final ContactNumber contactno3 = new ContactNumber(0, "Jason", "(415)-123-4567", "0", 1);
+        trie.put(contactno3);
+        assertTrue(checkContains(trie, contactno3, "4151234567"));
+        assertTrue(checkContains(trie, contactno3, "1234567"));
+
+        // Number without +1 prefix but is a NANP number
+        final ContactNumber contactno4 = new ContactNumber(0, "Mike", "1 510-284-9170", "0", 1);
+        trie.put(contactno4);
+        assertTrue(checkContains(trie, contactno4, "15102849170"));
+        assertTrue(checkContains(trie, contactno4, "5102849170"));
+        assertTrue(checkContains(trie, contactno4, "2849170"));
+
+        // Invalid number(has 1 prefix, but is only 10 characters long)
+        final ContactNumber contactno5 = new ContactNumber(0, "Invalid", "1-415-123-123", "0", 1);
+        trie.put(contactno5);
+        // It should still be inserted as is
+        assertTrue(checkContains(trie, contactno5, "1415123123"));
+        // But the NANP special case handling should not work
+        assertFalse(checkContains(trie, contactno5, "415123123"));
+        assertFalse(checkContains(trie, contactno5, "123123"));
+
+        // Invalid number(only 9 characters long)
+        final ContactNumber contactno6 = new ContactNumber(0, "Invalid2", "415-123-123", "0", 1);
+        trie.put(contactno6);
+        // It should still be inserted as is
+        assertTrue(checkContains(trie, contactno6, "415123123"));
+        // But the NANP special case handling should not work
+        assertFalse(checkContains(trie, contactno6, "123123"));
+
+        // If user's region is determined to be not in North America, then the NANP number
+        // workarounds should not be applied
+        final SmartDialTrie trieNonNANP = new SmartDialTrie();
+
+        trieNonNANP.put(contactno3);
+        assertTrue(checkContains(trieNonNANP, contactno3, "4151234567"));
+        assertFalse(checkContains(trieNonNANP, contactno3, "1234567"));
+
+        trieNonNANP.put(contactno4);
+        assertTrue(checkContains(trieNonNANP, contactno4, "15102849170"));
+        assertFalse(checkContains(trieNonNANP, contactno4, "5102849170"));
+        assertFalse(checkContains(trieNonNANP, contactno4, "2849170"));
+    }
+
     public void testNodeConstructor() {
         final Node n = new Node();
         // Node member variables should not be initialized by default at construction to reduce
@@ -185,8 +281,8 @@ public class SmartDialTrieTest extends TestCase{
         final ContactNumber contact = new ContactNumber(0, "James", "510-527-2357", "0", 1);
         final ContactNumber contactNotIn = new ContactNumber(2, "Jason Smitt", "0", "2", 3);
         n.add(contact);
-        assertEquals(true, n.getContents().contains(contact));
-        assertEquals(false, n.getContents().contains(contactNotIn));
+        assertTrue(n.getContents().contains(contact));
+        assertFalse(n.getContents().contains(contactNotIn));
     }
 
     private boolean checkContains(SmartDialTrie trie, ContactNumber contact, CharSequence prefix) {