am afd650b7: Allow smart dialing to ignore country code/area code

* commit 'afd650b7f81f363a4bb554ff7199338aee1a49c2':
  Allow smart dialing to ignore country code/area code

7 files changed, 781 insertions, 55 deletions

diff --git a/src/com/android/dialer/dialpad/SmartDialCache.java b/src/com/android/dialer/dialpad/SmartDialCache.java
index 79cc72763..7a11b15d8 100644
--- a/src/com/android/dialer/dialpad/SmartDialCache.java
+++ b/src/com/android/dialer/dialpad/SmartDialCache.java
@@ -19,22 +19,27 @@ package com.android.dialer.dialpad;
 import static com.android.dialer.dialpad.SmartDialAdapter.LOG_TAG;
 
 import android.content.Context;
-import android.database.ContentObserver;
+import android.content.SharedPreferences;
 import android.database.Cursor;
 import android.net.Uri;
-import android.os.Handler;
+import android.preference.PreferenceManager;
 import android.provider.ContactsContract;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
 import android.provider.ContactsContract.Contacts;
 import android.provider.ContactsContract.Data;
 import android.provider.ContactsContract.Directory;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
 import android.util.Log;
 
 import com.android.contacts.common.util.StopWatch;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 
 import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
@@ -134,12 +139,23 @@ public class SmartDialCache {
                 + Data.IS_PRIMARY + " DESC";
     }
 
+    // Static set used to determine which countries use NANP numbers
+    public static Set<String> sNanpCountries = null;
+
     private SmartDialTrie mContactsCache;
     private static AtomicInteger mCacheStatus;
     private final int mNameDisplayOrder;
     private final Context mContext;
     private final static Object mLock = new Object();
 
+    /** The country code of the user's sim card obtained by calling getSimCountryIso*/
+    private static final String PREF_USER_SIM_COUNTRY_CODE =
+            "DialtactsActivity_user_sim_country_code";
+    private static final String PREF_USER_SIM_COUNTRY_CODE_DEFAULT = null;
+
+    private static String sUserSimCountryCode = PREF_USER_SIM_COUNTRY_CODE_DEFAULT;
+    private static boolean sUserInNanpRegion = false;
+
     public static final int CACHE_NEEDS_RECACHE = 1;
     public static final int CACHE_IN_PROGRESS = 2;
     public static final int CACHE_COMPLETED = 3;
@@ -151,6 +167,27 @@ public class SmartDialCache {
         Preconditions.checkNotNull(context, "Context must not be null");
         mContext = context.getApplicationContext();
         mCacheStatus = new AtomicInteger(CACHE_NEEDS_RECACHE);
+
+        final TelephonyManager manager = (TelephonyManager) context.getSystemService(
+                Context.TELEPHONY_SERVICE);
+        if (manager != null) {
+            sUserSimCountryCode = manager.getSimCountryIso();
+        }
+
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+
+        if (sUserSimCountryCode != null) {
+            // Update shared preferences with the latest country obtained from getSimCountryIso
+            prefs.edit().putString(PREF_USER_SIM_COUNTRY_CODE, sUserSimCountryCode).apply();
+        } else {
+            // Couldn't get the country from getSimCountryIso. Maybe we are in airplane mode.
+            // Try to load the settings, if any from SharedPreferences.
+            sUserSimCountryCode = prefs.getString(PREF_USER_SIM_COUNTRY_CODE,
+                    PREF_USER_SIM_COUNTRY_CODE_DEFAULT);
+        }
+
+        sUserInNanpRegion = isCountryNanp(sUserSimCountryCode);
+
     }
 
     private static SmartDialCache instance;
@@ -200,7 +237,7 @@ public class SmartDialCache {
                 return;
             }
             final SmartDialTrie cache = new SmartDialTrie(
-                    SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS);
+                    SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS, sUserInNanpRegion);
             try {
                 c.moveToPosition(-1);
                 int affinityCount = 0;
@@ -259,8 +296,7 @@ public class SmartDialCache {
             // the contacts again.
             if (mContactsCache == null) {
                 cacheContacts(mContext);
-                return (mContactsCache == null) ? new SmartDialTrie(
-                        SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS) : mContactsCache;
+                return (mContactsCache == null) ? new SmartDialTrie() : mContactsCache;
             } else {
                 // After waiting for the lock on mLock to be released, mContactsCache is now
                 // non-null due to the completion of the caching thread (Scenario 2). Go ahead
@@ -313,4 +349,54 @@ public class SmartDialCache {
         }
 
     }
+
+    public boolean getUserInNanpRegion() {
+        return sUserInNanpRegion;
+    }
+
+    /**
+     * Indicates whether the given country uses NANP numbers
+     *
+     * @param country ISO 3166 country code (case doesn't matter)
+     * @return True if country uses NANP numbers (e.g. US, Canada), false otherwise
+     */
+    @VisibleForTesting
+    static boolean isCountryNanp(String country) {
+        if (TextUtils.isEmpty(country)) {
+            return false;
+        }
+        if (sNanpCountries == null) {
+            sNanpCountries = initNanpCountries();
+        }
+        return sNanpCountries.contains(country.toUpperCase());
+    }
+
+    private static Set<String> initNanpCountries() {
+        final HashSet<String> result = new HashSet<String>();
+        result.add("US"); // United States
+        result.add("CA"); // Canada
+        result.add("AS"); // American Samoa
+        result.add("AI"); // Anguilla
+        result.add("AG"); // Antigua and Barbuda
+        result.add("BS"); // Bahamas
+        result.add("BB"); // Barbados
+        result.add("BM"); // Bermuda
+        result.add("VG"); // British Virgin Islands
+        result.add("KY"); // Cayman Islands
+        result.add("DM"); // Dominica
+        result.add("DO"); // Dominican Republic
+        result.add("GD"); // Grenada
+        result.add("GU"); // Guam
+        result.add("JM"); // Jamaica
+        result.add("PR"); // Puerto Rico
+        result.add("MS"); // Montserrat
+        result.add("MP"); // Northern Mariana Islands
+        result.add("KN"); // Saint Kitts and Nevis
+        result.add("LC"); // Saint Lucia
+        result.add("VC"); // Saint Vincent and the Grenadines
+        result.add("TT"); // Trinidad and Tobago
+        result.add("TC"); // Turks and Caicos Islands
+        result.add("VI"); // U.S. Virgin Islands
+        return result;
+    }
 }
diff --git a/src/com/android/dialer/dialpad/SmartDialLoaderTask.java b/src/com/android/dialer/dialpad/SmartDialLoaderTask.java
index c5fc65761..08c526503 100644
--- a/src/com/android/dialer/dialpad/SmartDialLoaderTask.java
+++ b/src/com/android/dialer/dialpad/SmartDialLoaderTask.java
@@ -93,6 +93,8 @@ public class SmartDialLoaderTask extends AsyncTask<String, Integer, List<SmartDi
     private ArrayList<SmartDialEntry> getContactMatches() {
 
         final SmartDialTrie trie = mContactsCache.getContacts();
+        final boolean matchNanp = mContactsCache.getUserInNanpRegion();
+
         if (DEBUG) {
             Log.d(LOG_TAG, "Size of cache: " + trie.size());
         }
@@ -119,12 +121,14 @@ public class SmartDialLoaderTask extends AsyncTask<String, Integer, List<SmartDi
             }
             duplicates.add(contactMatch);
             final boolean matches = mNameMatcher.matches(contact.displayName);
+
             candidates.add(new SmartDialEntry(
                     contact.displayName,
                     Contacts.getLookupUri(contact.id, contact.lookupKey),
                     contact.phoneNumber,
                     mNameMatcher.getMatchPositions(),
-                    mNameMatcher.matchesNumber(contact.phoneNumber, mNameMatcher.getQuery())
+                    SmartDialNameMatcher.matchesNumber(contact.phoneNumber,
+                            mNameMatcher.getQuery(), matchNanp)
                     ));
             if (candidates.size() >= MAX_ENTRIES) {
                 break;
diff --git a/src/com/android/dialer/dialpad/SmartDialNameMatcher.java b/src/com/android/dialer/dialpad/SmartDialNameMatcher.java
index f805abff1..4d3948100 100644
--- a/src/com/android/dialer/dialpad/SmartDialNameMatcher.java
+++ b/src/com/android/dialer/dialpad/SmartDialNameMatcher.java
@@ -437,20 +437,54 @@ public class SmartDialNameMatcher {
     }
 
     /**
+     * Matches a phone number against a query, taking care of formatting characters and also
+     * taking into account country code prefixes and special NANP number treatment.
+     *
+     * @param phoneNumber - Raw phone number
+     * @param query - Normalized query (only contains numbers from 0-9)
+     * @param matchNanp - Whether or not to do special matching for NANP numbers
+     * @return {@literal null} if the number and the query don't match, a valid
+     *         SmartDialMatchPosition with the matching positions otherwise
+     */
+    public static SmartDialMatchPosition matchesNumber(String phoneNumber, String query,
+            boolean matchNanp) {
+        // Try matching the number as is
+        SmartDialMatchPosition matchPos = matchesNumberWithOffset(phoneNumber, query, 0);
+        if (matchPos == null) {
+            // Try matching the number without the '+' prefix, if any
+            int offset = SmartDialTrie.getOffsetWithoutCountryCode(phoneNumber);
+            if (offset > 0) {
+                matchPos = matchesNumberWithOffset(phoneNumber, query, offset);
+            } else if (matchNanp) {
+                // Try matching NANP numbers
+                final int[] offsets = SmartDialTrie.getOffsetForNANPNumbers(phoneNumber);
+                for (int i = 0; i < offsets.length; i++) {
+                    matchPos = matchesNumberWithOffset(phoneNumber, query, offsets[i]);
+                    if (matchPos != null) break;
+                }
+            }
+        }
+        return matchPos;
+    }
+
+    /**
      * Matches a phone number against a query, taking care of formatting characters
      *
      * @param phoneNumber - Raw phone number
      * @param query - Normalized query (only contains numbers from 0-9)
+     * @param offset - The position in the number to start the match against (used to ignore
+     * leading prefixes/country codes)
      * @return {@literal null} if the number and the query don't match, a valid
      *         SmartDialMatchPosition with the matching positions otherwise
      */
-    public SmartDialMatchPosition matchesNumber(String phoneNumber, String query) {
+    private static SmartDialMatchPosition matchesNumberWithOffset(String phoneNumber, String query,
+            int offset) {
         if (TextUtils.isEmpty(phoneNumber) || TextUtils.isEmpty(query)) {
             return null;
         }
         int queryAt = 0;
-        int numberAt = 0;
-        for (int i = 0; i < phoneNumber.length(); i++) {
+        int numberAt = offset;
+        for (int i = offset; i < phoneNumber.length(); i++) {
             if (queryAt == query.length()) {
                 break;
             }
@@ -460,13 +494,25 @@ public class SmartDialNameMatcher {
                     return null;
                 }
                 queryAt++;
-                numberAt++;
             } else {
-                numberAt++;
-                continue;
+                if (queryAt == 0) {
+                    // Found a separator before any part of the query was matched, so advance the
+                    // offset to avoid prematurely highlighting separators before the rest of the
+                    // query.
+                    // E.g. don't highlight the first '-' if we're matching 1-510-111-1111 with
+                    // '510'.
+                    // However, if the current offset is 0, just include the beginning separators
+                    // anyway, otherwise the highlighting ends up looking weird.
+                    // E.g. if we're matching (510)-111-1111 with '510', we should include the
+                    // first '('.
+                    if (offset != 0) {
+                        offset++;
+                    }
+                }
             }
+            numberAt++;
         }
-        return new SmartDialMatchPosition(0, numberAt);
+        return new SmartDialMatchPosition(0 + offset, numberAt);
     }
 
     /**
diff --git a/src/com/android/dialer/dialpad/SmartDialTrie.java b/src/com/android/dialer/dialpad/SmartDialTrie.java
index 981926717..9dfc0c95a 100644
--- a/src/com/android/dialer/dialpad/SmartDialTrie.java
+++ b/src/com/android/dialer/dialpad/SmartDialTrie.java
@@ -20,27 +20,58 @@ import android.text.TextUtils;
 
 import com.android.dialer.dialpad.SmartDialCache.ContactNumber;
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Prefix trie where the only allowed characters are the characters '0' to '9'. Multiple contacts
- * can occupy the same nodes. Provides functions to get all contacts that lie on or below a node.
- * This is useful for retrieving all contacts that start with that prefix.
+ * can occupy the same nodes.
+ *
+ * <p>Provides functions to get all contacts that lie on or below a node.
+ * This is useful for retrieving all contacts that start with that prefix.</p>
+ *
+ * <p>Also contains special logic to handle NANP numbers in the case that the user is from a region
+ * that uses NANP numbers.</p>
  */
 public class SmartDialTrie {
     final Node mRoot = new Node();
     private int mSize = 0;
     private final char[] mCharacterMap;
+    private final boolean mFormatNanp;
+
+    // Static set of all possible country codes in the world
+    public static Set<String> sCountryCodes = null;
 
     public SmartDialTrie() {
         // Use the latin letter to digit map by default if none provided
-        this(SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS);
+        this(SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS, false);
+    }
+
+    /**
+     * Creates a new SmartDialTrie.
+     *
+     * @param formatNanp True if inserted numbers are to be treated as NANP numbers
+     * such that numbers are automatically broken up by country prefix and area code.
+     */
+    @VisibleForTesting
+    public SmartDialTrie(boolean formatNanp) {
+        this(SmartDialNameMatcher.LATIN_LETTERS_TO_DIGITS, formatNanp);
     }
 
-    public SmartDialTrie(char[] charMap) {
+    /**
+     * Creates a new SmartDialTrie.
+     *
+     * @param charMap Mapping of characters to digits to use when inserting names into the trie.
+     * @param formatNanp True if inserted numbers are to be treated as NANP numbers
+     * such that numbers are automatically broken up by country prefix and area code.
+     */
+    public SmartDialTrie(char[] charMap, boolean formatNanp) {
         mCharacterMap = charMap;
+        mFormatNanp = formatNanp;
     }
 
     /**
@@ -90,10 +121,100 @@ public class SmartDialTrie {
         putForPrefix(contact, mRoot, toByteArray(contact.displayName), 0,
                 contact.displayName.length(), true, true);
         // We don't need to do the same for phone numbers since we only make one pass over them.
-        putNumber(contact, contact.phoneNumber);
+        // Strip the calling code from the phone number here
+        if (!TextUtils.isEmpty(contact.phoneNumber)) {
+            // Handle country codes for numbers with a + prefix
+            final int offset = getOffsetWithoutCountryCode(contact.phoneNumber);
+            if (offset > 0) {
+                putNumber(contact, contact.phoneNumber, offset);
+            } else if (mFormatNanp) {
+                // Special case handling for NANP numbers (1-xxx-xxx-xxxx)
+                final String stripped = SmartDialNameMatcher.normalizeNumber(contact.phoneNumber);
+                if (!TextUtils.isEmpty(stripped)) {
+                    int trunkPrefixOffset = 0;
+                    if (stripped.charAt(0) == '1') {
+                        // If the number starts with 1, we can assume its the trunk prefix.
+                        trunkPrefixOffset = 1;
+                    }
+                    if (stripped.length() == (10 + trunkPrefixOffset)) {
+                        // Valid NANP number
+                        if (trunkPrefixOffset != 0) {
+                            // Add the digits that follow the 1st digit (trunk prefix)
+                            // If trunkPrefixOffset is 0, we will add the number as is anyway, so
+                            // don't bother.
+                            putNumber(contact, stripped, trunkPrefixOffset);
+                        }
+                        // Add the digits that follow the next 3 digits (area code)
+                        putNumber(contact, stripped, 3 + trunkPrefixOffset);
+                    }
+                }
+            }
+            putNumber(contact, contact.phoneNumber);
+        }
         mSize++;
     }
 
+    public static int getOffsetWithoutCountryCode(String number) {
+        if (!TextUtils.isEmpty(number)) {
+            if (number.charAt(0) == '+') {
+                // check for international code here
+                for (int i = 1; i <= 1 + 3; i++) {
+                    if (number.length() <= i) break;
+                    if (isValidCountryCode(number.substring(1, i))) {
+                        return i;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Used by SmartDialNameMatcher to determine which character in the phone number to start
+     * the matching process from for a NANP formatted number.
+     *
+     * @param number Raw phone number
+     * @return An empty array if the provided number does not appear to be an NANP number,
+     * and an array containing integer offsets for the number (starting after the '1' prefix,
+     * and the area code prefix respectively.
+     */
+    public static int[] getOffsetForNANPNumbers(String number) {
+        int validDigits = 0;
+        boolean hasPrefix = false;
+        int firstOffset = 0; // Tracks the location of the first digit after the '1' prefix
+        int secondOffset = 0; // Tracks the location of the first digit after the area code
+        for (int i = 0; i < number.length(); i++) {
+            final char ch = number.charAt(i);
+            if (ch >= '0' && ch <= '9') {
+                if (validDigits == 0) {
+                    // Check the first digit to see if it is 1
+                    if (ch == '1') {
+                        if (hasPrefix) {
+                            // Prefix has two '1's in a row. Invalid number, since area codes
+                            // cannot start with 1, so just bail
+                            break;
+                        }
+                        hasPrefix = true;
+                        continue;
+                    }
+                }
+                validDigits++;
+                if (validDigits == 1) {
+                    // Found the first digit after the country code
+                    firstOffset = i;
+                } else if (validDigits == 4) {
+                    // Found the first digit after the area code
+                    secondOffset = i;
+                }
+            }
+
+        }
+        if (validDigits == 10) {
+            return hasPrefix ? new int[] {firstOffset, secondOffset} : new int[] {secondOffset};
+        }
+        return new int[0];
+    }
+
     @VisibleForTesting
     /* package */ byte[] toByteArray(CharSequence chars) {
         final int length = chars.length();
@@ -115,12 +236,24 @@ public class SmartDialTrie {
      *
      * @param contact - Contact to add to the trie
      * @param phoneNumber - Phone number of the contact
+    */
+    private void putNumber(ContactNumber contact, String phoneNumber) {
+        putNumber(contact, phoneNumber, 0);
+    }
+
+    /**
+     * Puts a phone number and its associated contact into the prefix trie.
+     *
+     * @param contact - Contact to add to the trie
+     * @param phoneNumber - Phone number of the contact
+     * @param offset - The nth character of the phone number to start from
      */
-    public void putNumber(ContactNumber contact, String phoneNumber) {
+    private void putNumber(ContactNumber contact, String phoneNumber, int offSet) {
+        Preconditions.checkArgument(offSet < phoneNumber.length());
         Node current = mRoot;
         final int length = phoneNumber.length();
         char ch;
-        for (int i = 0; i < length; i++) {
+        for (int i = offSet; i < length; i++) {
             ch = phoneNumber.charAt(i);
             if (ch >= '0' && ch <= '9') {
                 current = current.getChild(ch, true);
@@ -183,6 +316,7 @@ public class SmartDialTrie {
         current.add(contact);
     }
 
+    @VisibleForTesting
     public int size() {
         return mSize;
     }
@@ -247,4 +381,231 @@ public class SmartDialTrie {
             return mContents;
         }
     }
+
+    private static boolean isValidCountryCode(String countryCode) {
+        if (sCountryCodes == null) {
+            sCountryCodes = initCountryCodes();
+        }
+        return sCountryCodes.contains(countryCode);
+    }
+
+    private static Set<String> initCountryCodes() {
+        final HashSet<String> result = new HashSet<String>();
+        result.add("1");
+        result.add("7");
+        result.add("20");
+        result.add("27");
+        result.add("30");
+        result.add("31");
+        result.add("32");
+        result.add("33");
+        result.add("34");
+        result.add("36");
+        result.add("39");
+        result.add("40");
+        result.add("41");
+        result.add("43");
+        result.add("44");
+        result.add("45");
+        result.add("46");
+        result.add("47");
+        result.add("48");
+        result.add("49");
+        result.add("51");
+        result.add("52");
+        result.add("53");
+        result.add("54");
+        result.add("55");
+        result.add("56");
+        result.add("57");
+        result.add("58");
+        result.add("60");
+        result.add("61");
+        result.add("62");
+        result.add("63");
+        result.add("64");
+        result.add("65");
+        result.add("66");
+        result.add("81");
+        result.add("82");
+        result.add("84");
+        result.add("86");
+        result.add("90");
+        result.add("91");
+        result.add("92");
+        result.add("93");
+        result.add("94");
+        result.add("95");
+        result.add("98");
+        result.add("211");
+        result.add("212");
+        result.add("213");
+        result.add("216");
+        result.add("218");
+        result.add("220");
+        result.add("221");
+        result.add("222");
+        result.add("223");
+        result.add("224");
+        result.add("225");
+        result.add("226");
+        result.add("227");
+        result.add("228");
+        result.add("229");
+        result.add("230");
+        result.add("231");
+        result.add("232");
+        result.add("233");
+        result.add("234");
+        result.add("235");
+        result.add("236");
+        result.add("237");
+        result.add("238");
+        result.add("239");
+        result.add("240");
+        result.add("241");
+        result.add("242");
+        result.add("243");
+        result.add("244");
+        result.add("245");
+        result.add("246");
+        result.add("247");
+        result.add("248");
+        result.add("249");
+        result.add("250");
+        result.add("251");
+        result.add("252");
+        result.add("253");
+        result.add("254");
+        result.add("255");
+        result.add("256");
+        result.add("257");
+        result.add("258");
+        result.add("260");
+        result.add("261");
+        result.add("262");
+        result.add("263");
+        result.add("264");
+        result.add("265");
+        result.add("266");
+        result.add("267");
+        result.add("268");
+        result.add("269");
+        result.add("290");
+        result.add("291");
+        result.add("297");
+        result.add("298");
+        result.add("299");
+        result.add("350");
+        result.add("351");
+        result.add("352");
+        result.add("353");
+        result.add("354");
+        result.add("355");
+        result.add("356");
+        result.add("357");
+        result.add("358");
+        result.add("359");
+        result.add("370");
+        result.add("371");
+        result.add("372");
+        result.add("373");
+        result.add("374");
+        result.add("375");
+        result.add("376");
+        result.add("377");
+        result.add("378");
+        result.add("379");
+        result.add("380");
+        result.add("381");
+        result.add("382");
+        result.add("385");
+        result.add("386");
+        result.add("387");
+        result.add("389");
+        result.add("420");
+        result.add("421");
+        result.add("423");
+        result.add("500");
+        result.add("501");
+        result.add("502");
+        result.add("503");
+        result.add("504");
+        result.add("505");
+        result.add("506");
+        result.add("507");
+        result.add("508");
+        result.add("509");
+        result.add("590");
+        result.add("591");
+        result.add("592");
+        result.add("593");
+        result.add("594");
+        result.add("595");
+        result.add("596");
+        result.add("597");
+        result.add("598");
+        result.add("599");
+        result.add("670");
+        result.add("672");
+        result.add("673");
+        result.add("674");
+        result.add("675");
+        result.add("676");
+        result.add("677");
+        result.add("678");
+        result.add("679");
+        result.add("680");
+        result.add("681");
+        result.add("682");
+        result.add("683");
+        result.add("685");
+        result.add("686");
+        result.add("687");
+        result.add("688");
+        result.add("689");
+        result.add("690");
+        result.add("691");
+        result.add("692");
+        result.add("800");
+        result.add("808");
+        result.add("850");
+        result.add("852");
+        result.add("853");
+        result.add("855");
+        result.add("856");
+        result.add("870");
+        result.add("878");
+        result.add("880");
+        result.add("881");
+        result.add("882");
+        result.add("883");
+        result.add("886");
+        result.add("888");
+        result.add("960");
+        result.add("961");
+        result.add("962");
+        result.add("963");
+        result.add("964");
+        result.add("965");
+        result.add("966");
+        result.add("967");
+        result.add("968");
+        result.add("970");
+        result.add("971");
+        result.add("972");
+        result.add("973");
+        result.add("974");
+        result.add("975");
+        result.add("976");
+        result.add("977");
+        result.add("979");
+        result.add("992");
+        result.add("993");
+        result.add("994");
+        result.add("995");
+        result.add("996");
+        result.add("998");
+        return result;
+    }
 }
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) {