diff --git a/res/mipmap-hdpi/ic_launcher_contacts.png b/res/mipmap-hdpi/ic_launcher_contacts.png
index 3e1ea44..e935f52 100644
--- a/res/mipmap-hdpi/ic_launcher_contacts.png
+++ b/res/mipmap-hdpi/ic_launcher_contacts.png
Binary files differ
diff --git a/res/mipmap-mdpi/ic_launcher_contacts.png b/res/mipmap-mdpi/ic_launcher_contacts.png
index 618630f..155ba5a 100644
--- a/res/mipmap-mdpi/ic_launcher_contacts.png
+++ b/res/mipmap-mdpi/ic_launcher_contacts.png
Binary files differ
diff --git a/res/values-xlarge/styles.xml b/res/values-xlarge/styles.xml
index 41f947a..e601590 100644
--- a/res/values-xlarge/styles.xml
+++ b/res/values-xlarge/styles.xml
@@ -94,7 +94,7 @@
         <item name="android:background">@drawable/directory_bg_holo</item>
     </style>
 
-    <style name="NonPhoneActivityTheme" parent="@android:Theme.Holo.Light.Dialog">
+    <style name="NonPhoneDialogTheme" parent="@android:Theme.Holo.Light.Dialog.Alert">
     </style>
 
     <style name="BackgroundOnly" parent="@android:Theme.Holo.Light">
diff --git a/res/values/config.xml b/res/values/config.xml
new file mode 100644
index 0000000..6ebaa1f
--- /dev/null
+++ b/res/values/config.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<resources>
+
+    <!-- Amount of memory in bytes allocated for photo cache -->
+    <integer name="config_photo_cache_max_bytes">2000000</integer>
+
+    <!-- Number of decoded photo bitmaps retained in an LRU cache -->
+    <integer name="config_photo_cache_max_bitmaps">48</integer>
+</resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index bba6e5b..db50204 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -197,7 +197,10 @@
         <item name="android:background">@drawable/directory_bg</item>
     </style>
 
-    <style name="NonPhoneActivityTheme" parent="@android:Theme.Dialog">
+    <style name="NonPhoneActivityTheme" parent="@android:Theme.Translucent">
+    </style>
+
+    <style name="NonPhoneDialogTheme" parent="@android:Theme.Dialog">
     </style>
 
     <style name="SectionDivider">
diff --git a/src/com/android/contacts/ContactPhotoManager.java b/src/com/android/contacts/ContactPhotoManager.java
index ddd6a0e..914b697 100644
--- a/src/com/android/contacts/ContactPhotoManager.java
+++ b/src/com/android/contacts/ContactPhotoManager.java
@@ -21,6 +21,7 @@
 
 import android.content.ContentResolver;
 import android.content.Context;
+import android.content.res.Resources;
 import android.database.Cursor;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
@@ -29,9 +30,13 @@
 import android.os.Handler.Callback;
 import android.os.HandlerThread;
 import android.os.Message;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
 import android.provider.ContactsContract.Contacts.Photo;
 import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Directory;
 import android.util.Log;
+import android.util.LruCache;
 import android.widget.ImageView;
 
 import java.io.ByteArrayOutputStream;
@@ -104,6 +109,12 @@
      * if so.
      */
     public abstract void refreshCache();
+
+    /**
+     * Initiates a background process that over time will fill up cache with
+     * preload photos.
+     */
+    public abstract void preloadPhotosInBackground();
 }
 
 class ContactPhotoManagerImpl extends ContactPhotoManager implements Callback {
@@ -123,29 +134,44 @@
 
     private static final String[] EMPTY_STRING_ARRAY = new String[0];
 
-    private final String[] COLUMNS = new String[] { Photo._ID, Photo.PHOTO };
+    private static final String[] COLUMNS = new String[] { Photo._ID, Photo.PHOTO };
 
     /**
      * Maintains the state of a particular photo.
      */
     private static class BitmapHolder {
-        private static final int NEEDED = 0;
-        private static final int LOADING = 1;
-        private static final int LOADED = 2;
-        private static final int LOADED_NEEDS_RELOAD = 3;
+        final byte[] bytes;
 
-        int state;
+        volatile boolean fresh;
         Bitmap bitmap;
         SoftReference<Bitmap> bitmapRef;
+
+        public BitmapHolder(byte[] bytes) {
+            this.bytes = bytes;
+            this.fresh = true;
+        }
     }
 
     private final Context mContext;
 
     /**
-     * A soft cache for photos.
+     * An LRU cache for bitmap holders. The cache contains bytes for photos just
+     * as they come from the database. Each holder has a soft reference to the
+     * actual bitmap.
      */
-    private final ConcurrentHashMap<Object, BitmapHolder> mBitmapCache =
-            new ConcurrentHashMap<Object, BitmapHolder>();
+    private final LruCache<Object, BitmapHolder> mBitmapHolderCache;
+
+    /**
+     * Cache size threshold at which bitmaps will not be preloaded.
+     */
+    private final int mBitmapHolderCacheRedZoneBytes;
+
+    /**
+     * Level 2 LRU cache for bitmaps. This is a smaller cache that holds
+     * the most recently used bitmaps to save time on decoding
+     * them from bytes (the bytes are stored in {@link #mBitmapHolderCache}.
+     */
+    private final LruCache<Object, Bitmap> mBitmapCache;
 
     /**
      * A map from ImageView to the corresponding photo ID. Please note that this
@@ -177,6 +203,23 @@
 
     public ContactPhotoManagerImpl(Context context) {
         mContext = context;
+
+        Resources resources = context.getResources();
+        mBitmapCache = new LruCache<Object, Bitmap>(
+                resources.getInteger(R.integer.config_photo_cache_max_bitmaps));
+        int maxBytes = resources.getInteger(R.integer.config_photo_cache_max_bytes);
+        mBitmapHolderCache = new LruCache<Object, BitmapHolder>(maxBytes) {
+            @Override protected int sizeOf(Object key, BitmapHolder value) {
+                return value.bytes != null ? value.bytes.length : 0;
+            }
+        };
+        mBitmapHolderCacheRedZoneBytes = (int) (maxBytes * 0.75);
+    }
+
+    @Override
+    public void preloadPhotosInBackground() {
+        ensureLoaderThread();
+        mLoaderThread.requestPreloading();
     }
 
     @Override
@@ -216,58 +259,75 @@
 
     @Override
     public void refreshCache() {
-        for (BitmapHolder holder : mBitmapCache.values()) {
-            if (holder.state == BitmapHolder.LOADED) {
-                holder.state = BitmapHolder.LOADED_NEEDS_RELOAD;
-            }
+        for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
+            holder.fresh = false;
         }
     }
 
     /**
-     * Checks if the photo is present in cache.  If so, sets the photo on the view,
-     * otherwise sets the state of the photo to {@link BitmapHolder#NEEDED} and
-     * temporarily set the image to the default resource ID.
+     * Checks if the photo is present in cache.  If so, sets the photo on the view.
+     *
+     * @return false if the photo needs to be (re)loaded from the provider.
      */
     private boolean loadCachedPhoto(ImageView view, Object key) {
-        BitmapHolder holder = mBitmapCache.get(key);
+        BitmapHolder holder = mBitmapHolderCache.get(key);
         if (holder == null) {
-            holder = new BitmapHolder();
-            mBitmapCache.put(key, holder);
-        } else {
-            boolean loaded = (holder.state == BitmapHolder.LOADED);
-            boolean loadedNeedsReload = (holder.state == BitmapHolder.LOADED_NEEDS_RELOAD);
-            if (loadedNeedsReload) {
-                holder.state = BitmapHolder.NEEDED;
-            }
+            // The bitmap has not been loaded - should display the placeholder image.
+            view.setImageResource(mDefaultResourceId);
+            return false;
+        }
 
-            // Null bitmap reference means that database contains no bytes for the photo
-            if ((loaded || loadedNeedsReload) && holder.bitmapRef == null) {
-                view.setImageResource(mDefaultResourceId);
-                return loaded;
-            }
+        if (holder.bytes == null) {
+            view.setImageResource(mDefaultResourceId);
+            return holder.fresh;
+        }
 
-            if (holder.bitmapRef != null) {
-                Bitmap bitmap = holder.bitmapRef.get();
-                if (bitmap != null) {
-                    view.setImageBitmap(bitmap);
-                    return loaded;
-                }
+        // Optionally decode bytes into a bitmap
+        inflateBitmap(holder);
 
-                // Null bitmap means that the soft reference was released by the GC
-                // and we need to reload the photo.
-                holder.bitmapRef = null;
+        view.setImageBitmap(holder.bitmap);
+
+        // Put the bitmap in the LRU cache
+        mBitmapCache.put(key, holder.bitmap);
+
+        // Soften the reference
+        holder.bitmap = null;
+
+        return holder.fresh;
+    }
+
+    /**
+     * If necessary, decodes bytes stored in the holder to Bitmap.  As long as the
+     * bitmap is held either by {@link #mBitmapCache} or by a soft reference in
+     * the holder, it will not be necessary to decode the bitmap.
+     */
+    private void inflateBitmap(BitmapHolder holder) {
+        byte[] bytes = holder.bytes;
+        if (bytes == null || bytes.length == 0) {
+            return;
+        }
+
+        // Check the soft reference.  If will be retained if the bitmap is also
+        // in the LRU cache, so we don't need to check the LRU cache explicitly.
+        if (holder.bitmapRef != null) {
+            holder.bitmap = holder.bitmapRef.get();
+            if (holder.bitmap != null) {
+                return;
             }
         }
 
-        // The bitmap has not been loaded - should display the placeholder image.
-        view.setImageResource(mDefaultResourceId);
-        holder.state = BitmapHolder.NEEDED;
-        return false;
+        try {
+            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, null);
+            holder.bitmap = bitmap;
+            holder.bitmapRef = new SoftReference<Bitmap>(bitmap);
+        } catch (OutOfMemoryError e) {
+            // Do nothing - the photo will appear to be missing
+        }
     }
 
     public void clear() {
         mPendingRequests.clear();
-        mBitmapCache.clear();
+        mBitmapHolderCache.evictAll();
     }
 
     @Override
@@ -304,11 +364,7 @@
             case MESSAGE_REQUEST_LOADING: {
                 mLoadingRequested = false;
                 if (!mPaused) {
-                    if (mLoaderThread == null) {
-                        mLoaderThread = new LoaderThread(mContext.getContentResolver());
-                        mLoaderThread.start();
-                    }
-
+                    ensureLoaderThread();
                     mLoaderThread.requestLoading();
                 }
                 return true;
@@ -324,6 +380,13 @@
         return false;
     }
 
+    public void ensureLoaderThread() {
+        if (mLoaderThread == null) {
+            mLoaderThread = new LoaderThread(mContext.getContentResolver());
+            mLoaderThread.start();
+        }
+    }
+
     /**
      * Goes over pending loading requests and displays loaded photos.  If some of the
      * photos still haven't been loaded, sends another request for image loading.
@@ -348,10 +411,10 @@
 
     /**
      * Removes strong references to loaded bitmaps to allow them to be garbage collected
-     * if needed.
+     * if needed.  Some of the bitmaps will still be retained by {@link #mBitmapCache}.
      */
     private void softenCache() {
-        for (BitmapHolder holder : mBitmapCache.values()) {
+        for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
             holder.bitmap = null;
         }
     }
@@ -359,23 +422,17 @@
     /**
      * Stores the supplied bitmap in cache.
      */
-    private void cacheBitmap(Object key, byte[] bytes) {
-        if (mPaused) {
-            return;
+    private void cacheBitmap(Object key, byte[] bytes, boolean preloading) {
+        BitmapHolder holder = new BitmapHolder(bytes);
+        holder.fresh = true;
+
+        // Unless this image is being preloaded, decode it right away while
+        // we are still on the background thread.
+        if (!preloading) {
+            inflateBitmap(holder);
         }
 
-        BitmapHolder holder = new BitmapHolder();
-        holder.state = BitmapHolder.LOADED;
-        if (bytes != null) {
-            try {
-                Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, null);
-                holder.bitmap = bitmap;
-                holder.bitmapRef = new SoftReference<Bitmap>(bitmap);
-            } catch (OutOfMemoryError e) {
-                // Do nothing - the photo will appear to be missing
-            }
-        }
-        mBitmapCache.put(key, holder);
+        mBitmapHolderCache.put(key, holder);
     }
 
     /**
@@ -398,10 +455,8 @@
         Iterator<Object> iterator = mPendingRequests.values().iterator();
         while (iterator.hasNext()) {
             Object key = iterator.next();
-            BitmapHolder holder = mBitmapCache.get(key);
-            if (holder != null && holder.state == BitmapHolder.NEEDED) {
-                // Assuming atomic behavior
-                holder.state = BitmapHolder.LOADING;
+            BitmapHolder holder = mBitmapHolderCache.get(key);
+            if (holder == null || !holder.fresh) {
                 if (key instanceof Long) {
                     photoIds.add((Long)key);
                     photoIdsAsStrings.add(key.toString());
@@ -417,28 +472,82 @@
      */
     private class LoaderThread extends HandlerThread implements Callback {
         private static final int BUFFER_SIZE = 1024*16;
+        private static final int MESSAGE_PRELOAD_PHOTOS = 0;
+        private static final int MESSAGE_LOAD_PHOTOS = 1;
+
+        /**
+         * A pause between preload batches that yields to the UI thread.
+         */
+        private static final int PHOTO_PRELOAD_DELAY = 50;
+
+        /**
+         * Number of photos to preload per batch.
+         */
+        private static final int PRELOAD_BATCH = 25;
+
+        /**
+         * Maximum number of photos to preload.  If the cache size is 2Mb and
+         * the expected average size of a photo is 4kb, then this number should be 2Mb/4kb = 500.
+         */
+        private static final int MAX_PHOTOS_TO_PRELOAD = 500;
 
         private final ContentResolver mResolver;
         private final StringBuilder mStringBuilder = new StringBuilder();
         private final ArrayList<Long> mPhotoIds = Lists.newArrayList();
         private final ArrayList<String> mPhotoIdsAsStrings = Lists.newArrayList();
         private final ArrayList<Uri> mPhotoUris = Lists.newArrayList();
+        private ArrayList<Long> mPreloadPhotoIds = Lists.newArrayList();
+
         private Handler mLoaderThreadHandler;
         private byte mBuffer[];
 
+        private static final int PRELOAD_STATUS_NOT_STARTED = 0;
+        private static final int PRELOAD_STATUS_IN_PROGRESS = 1;
+        private static final int PRELOAD_STATUS_DONE = 2;
+
+        private int mPreloadStatus = PRELOAD_STATUS_NOT_STARTED;
+
         public LoaderThread(ContentResolver resolver) {
             super(LOADER_THREAD_NAME);
             mResolver = resolver;
         }
 
-        /**
-         * Sends a message to this thread to load requested photos.
-         */
-        public void requestLoading() {
+        public void ensureHandler() {
             if (mLoaderThreadHandler == null) {
                 mLoaderThreadHandler = new Handler(getLooper(), this);
             }
-            mLoaderThreadHandler.sendEmptyMessage(0);
+        }
+
+        /**
+         * Kicks off preloading of the next batch of photos on the background thread.
+         * Preloading will happen after a delay: we want to yield to the UI thread
+         * as much as possible.
+         * <p>
+         * If preloading is already complete, does nothing.
+         */
+        public void requestPreloading() {
+            if (mPreloadStatus == PRELOAD_STATUS_DONE) {
+                return;
+            }
+
+            ensureHandler();
+            if (mLoaderThreadHandler.hasMessages(MESSAGE_LOAD_PHOTOS)) {
+                return;
+            }
+
+            mLoaderThreadHandler.sendEmptyMessageDelayed(
+                    MESSAGE_PRELOAD_PHOTOS, PHOTO_PRELOAD_DELAY);
+        }
+
+        /**
+         * Sends a message to this thread to load requested photos.  Cancels a preloading
+         * request, if any: we don't want preloading to impede loading of the photos
+         * we need to display now.
+         */
+        public void requestLoading() {
+            ensureHandler();
+            mLoaderThreadHandler.removeMessages(MESSAGE_PRELOAD_PHOTOS);
+            mLoaderThreadHandler.sendEmptyMessage(MESSAGE_LOAD_PHOTOS);
         }
 
         /**
@@ -446,56 +555,164 @@
          * to the main thread to process them.
          */
         public boolean handleMessage(Message msg) {
-            loadPhotosFromDatabase();
+            switch (msg.what) {
+                case MESSAGE_PRELOAD_PHOTOS:
+                    preloadPhotosInBackground();
+                    break;
+                case MESSAGE_LOAD_PHOTOS:
+                    loadPhotosInBackground();
+                    break;
+            }
             return true;
         }
 
-        private void loadPhotosFromDatabase() {
-            obtainPhotoIdsAndUrisToLoad(mPhotoIds, mPhotoIdsAsStrings, mPhotoUris);
-
-            int count = mPhotoIds.size();
-            if (count != 0) {
-                mStringBuilder.setLength(0);
-                mStringBuilder.append(Photo._ID + " IN(");
-                for (int i = 0; i < count; i++) {
-                    if (i != 0) {
-                        mStringBuilder.append(',');
-                    }
-                    mStringBuilder.append('?');
-                }
-                mStringBuilder.append(')');
-
-                Cursor cursor = null;
-                try {
-                    cursor = mResolver.query(Data.CONTENT_URI,
-                            COLUMNS,
-                            mStringBuilder.toString(),
-                            mPhotoIdsAsStrings.toArray(EMPTY_STRING_ARRAY),
-                            null);
-
-                    if (cursor != null) {
-                        while (cursor.moveToNext()) {
-                            Long id = cursor.getLong(0);
-                            byte[] bytes = cursor.getBlob(1);
-                            cacheBitmap(id, bytes);
-                            mPhotoIds.remove(id);
-                        }
-                    }
-                } finally {
-                    if (cursor != null) {
-                        cursor.close();
-                    }
-                }
-
-                // Remaining photos were not found in the database - mark the cache accordingly.
-                count = mPhotoIds.size();
-                for (int i = 0; i < count; i++) {
-                    cacheBitmap(mPhotoIds.get(i), null);
-                }
-                mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
+        /**
+         * The first time it is called, figures out which photos need to be preloaded.
+         * Each subsequent call preloads the next batch of photos and requests
+         * another cycle of preloading after a delay.  The whole process ends when
+         * we either run out of photos to preload or fill up cache.
+         */
+        private void preloadPhotosInBackground() {
+            if (mPreloadStatus == PRELOAD_STATUS_DONE) {
+                return;
             }
 
-            count = mPhotoUris.size();
+            if (mPreloadStatus == PRELOAD_STATUS_NOT_STARTED) {
+                queryPhotosForPreload();
+                if (mPreloadPhotoIds.isEmpty()) {
+                    mPreloadStatus = PRELOAD_STATUS_DONE;
+                } else {
+                    mPreloadStatus = PRELOAD_STATUS_IN_PROGRESS;
+                }
+                requestPreloading();
+                return;
+            }
+
+            if (mBitmapHolderCache.size() > mBitmapHolderCacheRedZoneBytes) {
+                mPreloadStatus = PRELOAD_STATUS_DONE;
+                return;
+            }
+
+            mPhotoIds.clear();
+            mPhotoIdsAsStrings.clear();
+
+            int count = 0;
+            int preloadSize = mPreloadPhotoIds.size();
+            while(preloadSize > 0 && mPhotoIds.size() < PRELOAD_BATCH) {
+                preloadSize--;
+                count++;
+                Long photoId = mPreloadPhotoIds.get(preloadSize);
+                mPhotoIds.add(photoId);
+                mPhotoIdsAsStrings.add(photoId.toString());
+                mPreloadPhotoIds.remove(preloadSize);
+            }
+
+            loadPhotosFromDatabase(false);
+
+            if (preloadSize == 0) {
+                mPreloadStatus = PRELOAD_STATUS_DONE;
+            }
+
+            Log.v(TAG, "Preloaded " + count + " photos. Photos in cache: "
+                    + mBitmapHolderCache.size()
+                    + ". Total size: " + mBitmapHolderCache.size());
+
+            requestPreloading();
+        }
+
+        private void queryPhotosForPreload() {
+            Cursor cursor = null;
+            try {
+                Uri uri = Contacts.CONTENT_URI.buildUpon().appendQueryParameter(
+                        ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(Directory.DEFAULT))
+                        .build();
+                cursor = mResolver.query(uri, new String[] { Contacts.PHOTO_ID },
+                        Contacts.PHOTO_ID + " NOT NULL AND " + Contacts.PHOTO_ID + "!=0",
+                        null,
+                        Contacts.STARRED + " DESC, " + Contacts.LAST_TIME_CONTACTED + " DESC"
+                                + " LIMIT " + MAX_PHOTOS_TO_PRELOAD);
+
+                if (cursor != null) {
+                    while (cursor.moveToNext()) {
+                        // Insert them in reverse order, because we will be taking
+                        // them from the end of the list for loading.
+                        mPreloadPhotoIds.add(0, cursor.getLong(0));
+                    }
+                }
+            } finally {
+                if (cursor != null) {
+                    cursor.close();
+                }
+            }
+        }
+
+        private void loadPhotosInBackground() {
+            obtainPhotoIdsAndUrisToLoad(mPhotoIds, mPhotoIdsAsStrings, mPhotoUris);
+            loadPhotosFromDatabase(true);
+            loadRemotePhotos();
+            requestPreloading();
+        }
+
+        private void loadPhotosFromDatabase(boolean preloading) {
+            int count = mPhotoIds.size();
+            if (count == 0) {
+                return;
+            }
+
+            // Remove loaded photos from the preload queue: we don't want
+            // the preloading process to load them again.
+            if (!preloading && mPreloadStatus == PRELOAD_STATUS_IN_PROGRESS) {
+                for (int i = 0; i < count; i++) {
+                    mPreloadPhotoIds.remove(mPhotoIds.get(i));
+                }
+                if (mPreloadPhotoIds.isEmpty()) {
+                    mPreloadStatus = PRELOAD_STATUS_DONE;
+                }
+            }
+
+            mStringBuilder.setLength(0);
+            mStringBuilder.append(Photo._ID + " IN(");
+            for (int i = 0; i < count; i++) {
+                if (i != 0) {
+                    mStringBuilder.append(',');
+                }
+                mStringBuilder.append('?');
+            }
+            mStringBuilder.append(')');
+
+            Cursor cursor = null;
+            try {
+                cursor = mResolver.query(Data.CONTENT_URI,
+                        COLUMNS,
+                        mStringBuilder.toString(),
+                        mPhotoIdsAsStrings.toArray(EMPTY_STRING_ARRAY),
+                        null);
+
+                if (cursor != null) {
+                    while (cursor.moveToNext()) {
+                        Long id = cursor.getLong(0);
+                        byte[] bytes = cursor.getBlob(1);
+                        cacheBitmap(id, bytes, preloading);
+                        mPhotoIds.remove(id);
+                    }
+                }
+            } finally {
+                if (cursor != null) {
+                    cursor.close();
+                }
+            }
+
+            // Remaining photos were not found in the database - mark the cache accordingly.
+            count = mPhotoIds.size();
+            for (int i = 0; i < count; i++) {
+                cacheBitmap(mPhotoIds.get(i), null, preloading);
+            }
+
+            mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
+        }
+
+        private void loadRemotePhotos() {
+            int count = mPhotoUris.size();
             for (int i = 0; i < count; i++) {
                 Uri uri = mPhotoUris.get(i);
                 if (mBuffer == null) {
@@ -513,15 +730,15 @@
                         } finally {
                             is.close();
                         }
-                        cacheBitmap(uri, baos.toByteArray());
+                        cacheBitmap(uri, baos.toByteArray(), false);
                         mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
                     } else {
                         Log.v(TAG, "Cannot load photo " + uri);
-                        cacheBitmap(uri, null);
+                        cacheBitmap(uri, null, false);
                     }
                 } catch (Exception ex) {
                     Log.v(TAG, "Cannot load photo " + uri, ex);
-                    cacheBitmap(uri, null);
+                    cacheBitmap(uri, null, false);
                 }
             }
         }
diff --git a/src/com/android/contacts/ContactsApplication.java b/src/com/android/contacts/ContactsApplication.java
index 42ea641..c925ec0 100644
--- a/src/com/android/contacts/ContactsApplication.java
+++ b/src/com/android/contacts/ContactsApplication.java
@@ -86,6 +86,7 @@
         if (ContactPhotoManager.CONTACT_PHOTO_SERVICE.equals(name)) {
             if (mContactPhotoManager == null) {
                 mContactPhotoManager = ContactPhotoManager.createContactPhotoManager(this);
+                mContactPhotoManager.preloadPhotosInBackground();
             }
             return mContactPhotoManager;
         }
diff --git a/src/com/android/contacts/SpecialCharSequenceMgr.java b/src/com/android/contacts/SpecialCharSequenceMgr.java
index 140e7d4..a047a68 100644
--- a/src/com/android/contacts/SpecialCharSequenceMgr.java
+++ b/src/com/android/contacts/SpecialCharSequenceMgr.java
@@ -184,7 +184,7 @@
     static boolean handleIMEIDisplay(Context context, String input, boolean useSystemWindow) {
         if (input.equals(MMI_IMEI_DISPLAY)) {
             int phoneType = ((TelephonyManager)context.getSystemService(
-                    Context.TELEPHONY_SERVICE)).getPhoneType();
+                    Context.TELEPHONY_SERVICE)).getCurrentPhoneType();
 
             if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
                 showIMEIPanel(context, useSystemWindow);
diff --git a/src/com/android/contacts/activities/NonPhoneActivity.java b/src/com/android/contacts/activities/NonPhoneActivity.java
index 758996b..26eed7c 100644
--- a/src/com/android/contacts/activities/NonPhoneActivity.java
+++ b/src/com/android/contacts/activities/NonPhoneActivity.java
@@ -65,7 +65,8 @@
         @Override
         public Dialog onCreateDialog(Bundle savedInstanceState) {
             final AlertDialog alertDialog;
-            alertDialog = new AlertDialog.Builder(getActivity()).create();
+            alertDialog = new AlertDialog.Builder(getActivity(), R.style.NonPhoneDialogTheme)
+                    .create();
             alertDialog.setTitle(R.string.non_phone_caption);
             alertDialog.setMessage(getArgumentPhoneNumber());
             alertDialog.setButton(DialogInterface.BUTTON_POSITIVE,
diff --git a/src/com/android/contacts/activities/ShowOrCreateActivity.java b/src/com/android/contacts/activities/ShowOrCreateActivity.java
index f47d42aa..7341430 100755
--- a/src/com/android/contacts/activities/ShowOrCreateActivity.java
+++ b/src/com/android/contacts/activities/ShowOrCreateActivity.java
@@ -216,7 +216,7 @@
                 final CharSequence message = getResources().getString(
                         R.string.add_contact_dlg_message_fmt, mCreateDescrip);
 
-                return new AlertDialog.Builder(this)
+                return new AlertDialog.Builder(this, AlertDialog.THEME_HOLO_LIGHT)
                         .setTitle(R.string.add_contact_dlg_title)
                         .setMessage(message)
                         .setPositiveButton(android.R.string.ok,
diff --git a/src/com/android/contacts/editor/KindSectionView.java b/src/com/android/contacts/editor/KindSectionView.java
index 77484ce..4ce8dda 100644
--- a/src/com/android/contacts/editor/KindSectionView.java
+++ b/src/com/android/contacts/editor/KindSectionView.java
@@ -34,6 +34,8 @@
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
+import java.util.ArrayList;
+
 /**
  * Custom view for an entire section of data as segmented by
  * {@link DataKind} around a {@link Data#MIMETYPE}. This view shows a
@@ -247,13 +249,26 @@
     }
 
     public void addItem() {
+        ValuesDelta values = null;
         // if this is a list, we can freely add. if not, only allow adding the first
-        if (!mKind.isList && getEditorCount() == 1)
-            return;
+        if (!mKind.isList) {
+            if (getEditorCount() == 1) {
+                return;
+            }
+
+            // If we already have an item, just make it visible
+            ArrayList<ValuesDelta> entries = mState.getMimeEntries(mKind.mimeType);
+            if (entries != null && entries.size() > 0) {
+                values = entries.get(0);
+            }
+        }
 
         // Insert a new child, create its view and set its focus
-        final ValuesDelta newValues = EntityModifier.insertChild(mState, mKind);
-        final View newField = createEditorView(newValues);
+        if (values == null) {
+            values = EntityModifier.insertChild(mState, mKind);
+        }
+
+        final View newField = createEditorView(values);
         newField.requestFocus();
 
         // For non-lists (e.g. Notes we can only have one field. in that case we need to disable