From 718e813fbdb905b083562c0a6cd087463bacc261 Mon Sep 17 00:00:00 2001
From: Amith Yamasani <yamasani@google.com>
Date: Wed, 11 Nov 2009 18:49:36 -0800
Subject: [PATCH] Fix for #2244624 : Keyboard freezes up sometimes

I think the cause for this is the Contacts database being updated. This
causes the keyboard to reload the contacts once every 30 minutes. Since it
loads it synchronously, it affects people with several thousand contacts.

Although in my tests, with 3000 contacts, the delay was only 600ms, I've
had several reports from long-time googlers about this problem, so I'm
switching to loading the contacts asynchronously in a background thread.

Also fix a potential problem with capitalizing "i" if a contact has "i" as
one of the names.
---
 .../inputmethod/latin/ContactsDictionary.java | 71 +++++++++++++++----
 1 file changed, 58 insertions(+), 13 deletions(-)

diff --git a/src/com/android/inputmethod/latin/ContactsDictionary.java b/src/com/android/inputmethod/latin/ContactsDictionary.java
index 6f7f4b6a4..fd7ba55fc 100644
--- a/src/com/android/inputmethod/latin/ContactsDictionary.java
+++ b/src/com/android/inputmethod/latin/ContactsDictionary.java
@@ -20,6 +20,8 @@ import android.content.ContentResolver;
 import android.content.Context;
 import android.database.ContentObserver;
 import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.SystemClock;
 import android.provider.ContactsContract.Contacts;
 
 public class ContactsDictionary extends ExpandableDictionary {
@@ -37,6 +39,11 @@ public class ContactsDictionary extends ExpandableDictionary {
 
     private long mLastLoadedContacts;
 
+    private boolean mUpdatingContacts;
+
+    // Use this lock before touching mUpdatingContacts & mRequiresDownload
+    private Object mUpdatingLock = new Object();
+
     public ContactsDictionary(Context context) {
         super(context);
         // Perform a managed query. The Activity will handle closing and requerying the cursor
@@ -46,11 +53,15 @@ public class ContactsDictionary extends ExpandableDictionary {
         cres.registerContentObserver(Contacts.CONTENT_URI, true, mObserver = new ContentObserver(null) {
             @Override
             public void onChange(boolean self) {
-                mRequiresReload = true;
+                synchronized (mUpdatingLock) {
+                    mRequiresReload = true;
+                }
             }
         });
 
-        loadDictionary();
+        synchronized (mUpdatingLock) {
+            loadDictionaryAsyncLocked();
+        }
     }
 
     public synchronized void close() {
@@ -60,29 +71,37 @@ public class ContactsDictionary extends ExpandableDictionary {
         }
     }
 
-    private synchronized void loadDictionary() {
-        long now = android.os.SystemClock.uptimeMillis();
+    private synchronized void loadDictionaryAsyncLocked() {
+        long now = SystemClock.uptimeMillis();
         if (mLastLoadedContacts == 0
                 || now - mLastLoadedContacts > 30 * 60 * 1000 /* 30 minutes */) {
-            Cursor cursor = getContext().getContentResolver()
-                    .query(Contacts.CONTENT_URI, PROJECTION, null, null, null);
-            if (cursor != null) {
-                addWords(cursor);
+            if (!mUpdatingContacts) {
+                mUpdatingContacts = true;
+                mRequiresReload = false;
+                new LoadContactsTask().execute();
             }
-            mRequiresReload = false;
-            mLastLoadedContacts = now;
         }
     }
 
     @Override
     public synchronized void getWords(final WordComposer codes, final WordCallback callback) {
-        if (mRequiresReload) loadDictionary();
+        synchronized (mUpdatingLock) {
+            // If we need to update, start off a background task
+            if (mRequiresReload) loadDictionaryAsyncLocked();
+            // Currently updating contacts, don't return any results.
+            if (mUpdatingContacts) return;
+        }
         super.getWords(codes, callback);
     }
 
     @Override
     public synchronized boolean isValidWord(CharSequence word) {
-        if (mRequiresReload) loadDictionary();
+        synchronized (mUpdatingLock) {
+            // If we need to update, start off a background task
+            if (mRequiresReload) loadDictionaryAsyncLocked();
+            if (mUpdatingContacts) return false;
+        }
+
         return super.isValidWord(word);
     }
 
@@ -115,7 +134,10 @@ public class ContactsDictionary extends ExpandableDictionary {
 
                             // Safeguard against adding really long words. Stack
                             // may overflow due to recursion
-                            if (word.length() < maxWordLength) {
+                            // Also don't add single letter words, possibly confuses
+                            // capitalization of i.
+                            final int wordLen = word.length();
+                            if (wordLen < maxWordLength && wordLen > 1) {
                                 super.addWord(word, 128);
                             }
                         }
@@ -127,4 +149,27 @@ public class ContactsDictionary extends ExpandableDictionary {
         }
         cursor.close();
     }
+    
+    private class LoadContactsTask extends AsyncTask<Void, Void, Void> {
+        @Override
+        protected Void doInBackground(Void... v) {
+            Cursor cursor = getContext().getContentResolver()
+                    .query(Contacts.CONTENT_URI, PROJECTION, null, null, null);
+            if (cursor != null) {
+                addWords(cursor);
+            }
+            mLastLoadedContacts = SystemClock.uptimeMillis();
+            return null;
+        }
+
+        @Override
+        protected void onPostExecute(Void result) {
+            // TODO Auto-generated method stub
+            synchronized (mUpdatingLock) {
+                mUpdatingContacts = false;
+            }
+            super.onPostExecute(result);
+        }
+        
+    }
 }