提交: d8a6d17db8aaef2ea06c78fe643f06601d8aec5d - packages-apps-Gallery2 (git)

packages/apps/Gallery2

Commit MetaInfo

• 修订版: d8a6d17db8aaef2ea06c78fe643f06601d8aec5d (tree)
• 时间: 2009-12-01 05:11:59
• 作者: Dave Sparks <davidsparks@andr...>
• Commiter: Dave Sparks

Log Message

Updates to 3D Gallery.

更改概述

• modified: AndroidManifest.xml
• modified: res/drawable/default_background.png
• modified: src/com/cooliris/cache/BootReceiver.java
• modified: src/com/cooliris/cache/CacheService.java
• add: src/com/cooliris/cache/ImageList.java
• add: src/com/cooliris/media/ActiveWallpaper.java
• modified: src/com/cooliris/media/AdaptiveBackgroundTexture.java
• modified: src/com/cooliris/media/ArrayUtils.java
• modified: src/com/cooliris/media/BackgroundLayer.java
• modified: src/com/cooliris/media/DiskCache.java
• modified: src/com/cooliris/media/FloatUtils.java
• modified: src/com/cooliris/media/Gallery.java
• modified: src/com/cooliris/media/GridCameraManager.java
• modified: src/com/cooliris/media/GridDrawManager.java
• modified: src/com/cooliris/media/GridDrawables.java
• modified: src/com/cooliris/media/GridInputProcessor.java
• modified: src/com/cooliris/media/GridLayer.java
• modified: src/com/cooliris/media/HudLayer.java
• modified: src/com/cooliris/media/ImageManager.java
• modified: src/com/cooliris/media/LocalDataSource.java
• modified: src/com/cooliris/media/MediaFeed.java
• modified: src/com/cooliris/media/MediaItem.java
• modified: src/com/cooliris/media/MediaItemTexture.java
• modified: src/com/cooliris/media/MenuBar.java
• modified: src/com/cooliris/media/PathBarLayer.java
• modified: src/com/cooliris/media/PicasaDataSource.java
• modified: src/com/cooliris/media/RenderView.java
• modified: src/com/cooliris/media/ReverseGeocoder.java
• modified: src/com/cooliris/media/TimeBar.java
• modified: src/com/cooliris/media/UriTexture.java
• modified: src/com/cooliris/picasa/PicasaApi.java
• add: src/com/cooliris/wallpaper/RandomDataSource.java
• add: src/com/cooliris/wallpaper/Slideshow.java

差异

--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -139,7 +139,8 @@
             <meta-data android:name="android.appwidget.provider" android:resource="@xml/appwidget_info" />
         </receiver>
 
-        <!-- We configure a widget by asking to pick a photo, then crop it, and store the config internally -->
+        <!-- We configure a widget by asking to pick a photo, then crop it, and store the config internally
+-->
         <activity android:name="PhotoAppWidgetConfigure">
             <intent-filter>
                 <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
@@ -148,7 +149,8 @@
 
         <!-- We also allow direct binding where the caller provides a bitmap and
              appWidgetId to bind.  We require the permission because this changes our
-             internal database without user confirmation. -->
+             internal database without user confirmation.
+-->
         <activity android:name="PhotoAppWidgetBind" android:exported="true"
                 android:theme="@android:style/Theme.NoDisplay"
                 android:permission="android.permission.BIND_APPWIDGET" />

Binary files a/res/drawable/default_background.png and b/res/drawable/default_background.png differ

--- a/src/com/cooliris/cache/BootReceiver.java
+++ b/src/com/cooliris/cache/BootReceiver.java
@@ -10,11 +10,11 @@ import android.net.Uri;
 import android.util.Log;
 
 public class BootReceiver extends BroadcastReceiver {
-    private final String TAG = "BootReceiver"; 
+    private static final String TAG = "BootReceiver"; 
 
     @Override
     public void onReceive(Context context, Intent intent) {
-        String action = intent.getAction();
+        final String action = intent.getAction();
         Log.i(TAG, "Got intent with action " + action);
         if (Intent.ACTION_MEDIA_SCANNER_FINISHED.equals(action)) {
             CacheService.markDirty(context);
@@ -23,8 +23,8 @@ public class BootReceiver extends BroadcastReceiver {
             // Do nothing, wait for the mediascanner to be done after mounting.
             ;
         } else if (action.equals(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE)) {
-            Uri fileUri = intent.getData();
-            long bucketId = SingleDataSource.parseBucketIdFromFileUri(fileUri.toString());
+            final Uri fileUri = intent.getData();
+            final long bucketId = SingleDataSource.parseBucketIdFromFileUri(fileUri.toString());
             if (!CacheService.isPresentInCache(bucketId)) {
                 CacheService.markDirty(context);
             }

--- a/src/com/cooliris/cache/CacheService.java
+++ b/src/com/cooliris/cache/CacheService.java
@@ -40,6 +40,7 @@ import android.util.Log;
 
 import com.cooliris.media.DataSource;
 import com.cooliris.media.DiskCache;
+import com.cooliris.media.Gallery;
 import com.cooliris.media.LocalDataSource;
 import com.cooliris.media.LongSparseArray;
 import com.cooliris.media.MediaFeed;
@@ -52,10 +53,12 @@ import com.cooliris.media.UriTexture;
 import com.cooliris.media.Utils;
 
 public final class CacheService extends IntentService {
-    private static final String TAG = "CacheService";
     public static final String ACTION_CACHE = "com.cooliris.cache.action.CACHE";
     public static final DiskCache sAlbumCache = new DiskCache("local-album-cache");
 
+    private static final String TAG = "CacheService";
+    private static ImageList sList = null;
+
     // Wait 2 seconds to start the thumbnailer so that the application can load without any overheads.
     private static final int THUMBNAILER_WAIT_IN_MS = 2000;
     private static final int DEFAULT_THUMBNAIL_WIDTH = 128;
@@ -81,8 +84,9 @@ public final class CacheService extends IntentService {
     public static final int THUMBNAIL_ID_INDEX = 0;
     public static final int THUMBNAIL_DATE_MODIFIED_INDEX = 1;
     public static final int THUMBNAIL_DATA_INDEX = 2;
+    public static final int THUMBNAIL_ORIENTATION_INDEX = 2;
     public static final String[] THUMBNAIL_PROJECTION = new String[] { Images.ImageColumns._ID, Images.ImageColumns.DATE_MODIFIED,
-            Images.ImageColumns.DATA };
+            Images.ImageColumns.DATA, Images.ImageColumns.ORIENTATION };
 
     // Must preserve order between these indices and the order of the terms in INITIAL_PROJECTION_IMAGES and
     // INITIAL_PROJECTION_VIDEOS.
@@ -121,26 +125,27 @@ public final class CacheService extends IntentService {
 
     private static final DateFormat mDateFormat = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss");
     private static final DateFormat mAltDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
+    private static final byte[] sDummyData = new byte[] { 1 };
     private static boolean QUEUE_DIRTY_SET;
     private static boolean QUEUE_DIRTY_ALL;
 
-    public static String getCachePath(String subFolderName) {
+    public static final String getCachePath(final String subFolderName) {
         return Environment.getExternalStorageDirectory() + "/Android/data/com.cooliris.media/cache/" + subFolderName;
     }
 
-    public static void startCache(final Context context, boolean checkthumbnails) {
-        Locale locale = getLocaleForAlbumCache();
-        Locale defaultLocale = Locale.getDefault();
+    public static final void startCache(final Context context, final boolean checkthumbnails) {
+        final Locale locale = getLocaleForAlbumCache();
+        final Locale defaultLocale = Locale.getDefault();
         if (locale == null || !locale.equals(defaultLocale)) {
             sAlbumCache.deleteAll();
-            putLocaleForAlbumCache(Locale.getDefault());
+            putLocaleForAlbumCache(defaultLocale);
         }
         final Intent intent = new Intent(ACTION_CACHE, null, context, CacheService.class);
         intent.putExtra("checkthumbnails", checkthumbnails);
         context.startService(intent);
     }
 
-    public static boolean isCacheReady(final boolean onlyMediaSets) {
+    public static final boolean isCacheReady(final boolean onlyMediaSets) {
         if (onlyMediaSets) {
             return (sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0) != null && sAlbumCache.get(ALBUM_CACHE_DIRTY_INDEX, 0) == null);
         } else {
@@ -149,17 +154,17 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public static boolean isCacheReady(long setId) {
-        boolean isReady = (sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0) != null
+    public static final boolean isCacheReady(final long setId) {
+        final boolean isReady = (sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0) != null
                 && sAlbumCache.get(ALBUM_CACHE_DIRTY_INDEX, 0) == null && sAlbumCache.get(ALBUM_CACHE_INCOMPLETE_INDEX, 0) == null);
         if (!isReady) {
             return isReady;
         }
         // Also, we need to check if this setId is dirty.
-        byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
+        final byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
         if (existingData != null && existingData.length > 0) {
-            long[] ids = toLongArray(existingData);
-            int numIds = ids.length;
+            final long[] ids = toLongArray(existingData);
+            final int numIds = ids.length;
             for (int i = 0; i < numIds; ++i) {
                 if (ids[i] == setId) {
                     return false;
@@ -169,13 +174,13 @@ public final class CacheService extends IntentService {
         return true;
     }
 
-    public static boolean isPresentInCache(long setId) {
+    public static final boolean isPresentInCache(final long setId) {
         return sAlbumCache.get(setId, 0) != null;
     }
 
-    public final static void markDirty(final Context context) {
-        byte[] data = new byte[] { 1 };
-        sAlbumCache.put(ALBUM_CACHE_DIRTY_INDEX, data);
+    public static final void markDirty(final Context context) {
+        sList = null;
+        sAlbumCache.put(ALBUM_CACHE_DIRTY_INDEX, sDummyData);
         if (CACHE_THREAD.get() == null) {
             restartThread(CACHE_THREAD, "CacheRefresh", new Runnable() {
                 public void run() {
@@ -187,12 +192,13 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public final static void markDirtyImmediate(long id) {
+    public static final void markDirtyImmediate(final long id) {
+        sList = null;
         byte[] data = longToByteArray(id);
-        byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
+        final byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
         if (existingData != null && existingData.length > 0) {
-            long[] ids = toLongArray(existingData);
-            int numIds = ids.length;
+            final long[] ids = toLongArray(existingData);
+            final int numIds = ids.length;
             for (int i = 0; i < numIds; ++i) {
                 if (ids[i] == id) {
                     return;
@@ -204,7 +210,7 @@ public final class CacheService extends IntentService {
         sAlbumCache.put(ALBUM_CACHE_DIRTY_BUCKET_INDEX, data);
     }
 
-    public final static void markDirty(final Context context, long id) {
+    public static final void markDirty(final Context context, final long id) {
         markDirtyImmediate(id);
         if (CACHE_THREAD.get() == null) {
             restartThread(CACHE_THREAD, "CacheRefreshDirtySets", new Runnable() {
@@ -217,10 +223,10 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public static boolean setHasItems(ContentResolver cr, long setId) {
+    public static final boolean setHasItems(final ContentResolver cr, final long setId) {
         final Uri uriImages = Images.Media.EXTERNAL_CONTENT_URI;
         final Uri uriVideos = Video.Media.EXTERNAL_CONTENT_URI;
-        StringBuffer whereString = new StringBuffer(Images.ImageColumns.BUCKET_ID + "=" + setId);
+        final StringBuffer whereString = new StringBuffer(Images.ImageColumns.BUCKET_ID + "=" + setId);
         final Cursor cursorImages = cr.query(uriImages, BUCKET_PROJECTION_IMAGES, whereString.toString(), null, null);
         if (cursorImages != null && cursorImages.getCount() > 0) {
             cursorImages.close();
@@ -234,7 +240,7 @@ public final class CacheService extends IntentService {
         return false;
     }
 
-    public static void loadMediaSets(final MediaFeed feed, final DataSource source, final boolean includeImages,
+    public static final void loadMediaSets(final MediaFeed feed, final DataSource source, final boolean includeImages,
             final boolean includeVideos) {
         int timeElapsed = 0;
         while (!isCacheReady(true) && timeElapsed < 10000) {
@@ -245,7 +251,7 @@ public final class CacheService extends IntentService {
             }
             timeElapsed += 300;
         }
-        byte[] albumData = sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0);
+        final byte[] albumData = sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0);
         if (albumData != null && albumData.length > 0) {
             final DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(albumData), 256));
             try {
@@ -278,7 +284,7 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public static void loadMediaSet(final MediaFeed feed, final DataSource source, final long bucketId) {
+    public static final void loadMediaSet(final MediaFeed feed, final DataSource source, final long bucketId) {
         int timeElapsed = 0;
         while (!isCacheReady(false) && timeElapsed < 10000) {
             try {
@@ -288,13 +294,13 @@ public final class CacheService extends IntentService {
             }
             timeElapsed += 300;
         }
-        byte[] albumData = sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0);
+        final byte[] albumData = sAlbumCache.get(ALBUM_CACHE_METADATA_INDEX, 0);
         if (albumData != null && albumData.length > 0) {
             DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(albumData), 256));
             try {
-                int numAlbums = dis.readInt();
+                final int numAlbums = dis.readInt();
                 for (int i = 0; i < numAlbums; ++i) {
-                    long setId = dis.readLong();
+                    final long setId = dis.readLong();
                     MediaSet mediaSet = null;
                     if (setId == bucketId) {
                         mediaSet = feed.getMediaSet(setId);
@@ -321,7 +327,7 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public static void loadMediaItemsIntoMediaFeed(final MediaFeed feed, final MediaSet set, final int rangeStart,
+    public static final void loadMediaItemsIntoMediaFeed(final MediaFeed feed, final MediaSet set, final int rangeStart,
             final int rangeEnd, final boolean includeImages, final boolean includeVideos) {
         int timeElapsed = 0;
         byte[] albumData = null;
@@ -337,13 +343,13 @@ public final class CacheService extends IntentService {
         if (albumData != null && set.mNumItemsLoaded < set.getNumExpectedItems()) {
             final DataInputStream dis = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(albumData), 256));
             try {
-                int numItems = dis.readInt();
+                final int numItems = dis.readInt();
                 Log.i(TAG, "Loading Set Id " + set.mId + " with " + numItems + " items.");
                 set.setNumExpectedItems(numItems);
                 set.mMinTimestamp = dis.readLong();
                 set.mMaxTimestamp = dis.readLong();
                 for (int i = 0; i < numItems; ++i) {
-                    MediaItem item = new MediaItem();
+                    final MediaItem item = new MediaItem();
                     // Must preserve order with method that writes to cache.
                     item.mId = dis.readLong();
                     item.mCaption = Utils.readUTF(dis);
@@ -380,61 +386,65 @@ public final class CacheService extends IntentService {
         set.generateTitle(true);
     }
 
-    public static void populateVideoItemFromCursor(MediaItem item, ContentResolver cr, Cursor cursor, String baseUri) {
+    public static final void populateVideoItemFromCursor(final MediaItem item, final ContentResolver cr, final Cursor cursor,
+            final String baseUri) {
         item.setMediaType(MediaItem.MEDIA_TYPE_VIDEO);
         populateMediaItemFromCursor(item, cr, cursor, baseUri);
     }
 
-    public static void populateMediaItemFromCursor(MediaItem item, ContentResolver cr, Cursor cursor, String baseUri) {
+    public static final void populateMediaItemFromCursor(final MediaItem item, final ContentResolver cr, final Cursor cursor,
+            final String baseUri) {
         item.mId = cursor.getLong(CacheService.MEDIA_ID_INDEX);
-        item.mCaption = cursor.getString(CacheService.MEDIA_CAPTION_INDEX);
+        //item.mCaption = cursor.getString(CacheService.MEDIA_CAPTION_INDEX);
         item.mMimeType = cursor.getString(CacheService.MEDIA_MIME_TYPE_INDEX);
         item.mLatitude = cursor.getDouble(CacheService.MEDIA_LATITUDE_INDEX);
         item.mLongitude = cursor.getDouble(CacheService.MEDIA_LONGITUDE_INDEX);
         item.mDateTakenInMs = cursor.getLong(CacheService.MEDIA_DATE_TAKEN_INDEX);
         item.mDateAddedInSec = cursor.getLong(CacheService.MEDIA_DATE_ADDED_INDEX);
         item.mDateModifiedInSec = cursor.getLong(CacheService.MEDIA_DATE_MODIFIED_INDEX);
+        if (item.mDateTakenInMs == item.mDateModifiedInSec) {
+            item.mDateTakenInMs = item.mDateModifiedInSec * 1000;
+        }
         item.mFilePath = cursor.getString(CacheService.MEDIA_DATA_INDEX);
-
-        int itemMediaType = item.getMediaType();
+        if (baseUri != null)
+            item.mContentUri = baseUri + item.mId;
+        final int itemMediaType = item.getMediaType();
         // Check to see if a new date taken is available.
-        long dateTaken = fetchDateTaken(item);
-        if (dateTaken != -1L) {
+        final long dateTaken = fetchDateTaken(item);
+        if (dateTaken != -1L && item.mContentUri != null) {
             item.mDateTakenInMs = dateTaken;
-            ContentValues values = new ContentValues();
+            final ContentValues values = new ContentValues();
             if (itemMediaType == MediaItem.MEDIA_TYPE_VIDEO) {
                 values.put(Video.VideoColumns.DATE_TAKEN, item.mDateTakenInMs);
             } else {
                 values.put(Images.ImageColumns.DATE_TAKEN, item.mDateTakenInMs);
             }
-            if (item.mContentUri != null) {
-                cr.update(Uri.parse(item.mContentUri), values, null, null);
-            }
+            cr.update(Uri.parse(item.mContentUri), values, null, null);
         }
 
-        int orientationDurationValue = cursor.getInt(CacheService.MEDIA_ORIENTATION_OR_DURATION_INDEX);
+        final int orientationDurationValue = cursor.getInt(CacheService.MEDIA_ORIENTATION_OR_DURATION_INDEX);
         if (itemMediaType == MediaItem.MEDIA_TYPE_IMAGE) {
             item.mRotation = orientationDurationValue;
         } else {
             item.mDurationInSec = orientationDurationValue;
         }
-        item.mContentUri = baseUri + item.mId;
     }
 
     // Returns -1 if we failed to examine EXIF information or EXIF parsing failed.
-    public static long fetchDateTaken(MediaItem item) {
+    public static final long fetchDateTaken(final MediaItem item) {
         if (!item.isDateTakenValid() && !item.mTriedRetrievingExifDateTaken
                 && (item.mFilePath.endsWith(".jpg") || item.mFilePath.endsWith(".jpeg"))) {
             try {
-                ExifInterface exif = new ExifInterface(item.mFilePath);
-                String dateTakenStr = exif.getAttribute(ExifInterface.TAG_DATETIME);
+                Log.i(TAG, "Parsing date taken from exif");
+                final ExifInterface exif = new ExifInterface(item.mFilePath);
+                final String dateTakenStr = exif.getAttribute(ExifInterface.TAG_DATETIME);
                 if (dateTakenStr != null) {
                     try {
-                        Date dateTaken = mDateFormat.parse(dateTakenStr);
+                        final Date dateTaken = mDateFormat.parse(dateTakenStr);
                         return dateTaken.getTime();
                     } catch (ParseException pe) {
                         try {
-                            Date dateTaken = mAltDateFormat.parse(dateTakenStr);
+                            final Date dateTaken = mAltDateFormat.parse(dateTakenStr);
                             return dateTaken.getTime();
                         } catch (ParseException pe2) {
                             Log.i(TAG, "Unable to parse date out of string - " + dateTakenStr);
@@ -451,73 +461,92 @@ public final class CacheService extends IntentService {
         return -1L;
     }
 
-    public static byte[] queryThumbnail(final Context context, final long thumbId, final long origId, final boolean isVideo,
+    public static final byte[] queryThumbnail(final Context context, final long thumbId, final long origId, final boolean isVideo,
             final long timestamp) {
         final DiskCache thumbnailCache = (isVideo) ? LocalDataSource.sThumbnailCacheVideo : LocalDataSource.sThumbnailCache;
         return queryThumbnail(context, thumbId, origId, isVideo, thumbnailCache, timestamp);
     }
 
-    private static byte[] queryThumbnail(final Context context, final long thumbId, final long origId, final boolean isVideo,
-            final DiskCache thumbnailCache, final long timestamp) {
-        Thread thumbnailThread = THUMBNAIL_THREAD.getAndSet(null);
-        if (thumbnailThread != null) {
-            thumbnailThread.interrupt();
-        }
-        byte[] bitmap = thumbnailCache.get(thumbId, timestamp);
-        if (bitmap == null) {
-            Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
-            long time = SystemClock.uptimeMillis();
-            bitmap = buildThumbnailForId(context, thumbnailCache, thumbId, origId, isVideo, DEFAULT_THUMBNAIL_WIDTH,
-                    DEFAULT_THUMBNAIL_HEIGHT);
-            Log.i(TAG, "Built thumbnail and screennail for " + origId + " in " + (SystemClock.uptimeMillis() - time));
-            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
-        }
-        return bitmap;
-    }
-
-    private static void buildThumbnails(final Context context) {
-        Log.i(TAG, "Preparing DiskCache for all thumbnails.");
+    public static final ImageList getImageList(final Context context) {
+        if (sList != null)
+            return sList;
+        ImageList list = new ImageList();
         final Uri uriImages = Images.Media.EXTERNAL_CONTENT_URI;
         final ContentResolver cr = context.getContentResolver();
         final Cursor cursorImages = cr.query(uriImages, THUMBNAIL_PROJECTION, null, null, null);
-        final DiskCache thumbnailCache = LocalDataSource.sThumbnailCache;
-
         if (cursorImages != null && cursorImages.moveToFirst()) {
             final int size = cursorImages.getCount();
             final long[] ids = new long[size];
             final long[] thumbnailIds = new long[size];
             final long[] timestamp = new long[size];
+            final int[] orientation = new int[size];
             int ctr = 0;
             do {
                 if (Thread.interrupted()) {
-                    return;
-                }
-                synchronized (thumbnailCache) {
-                    ids[ctr] = cursorImages.getLong(THUMBNAIL_ID_INDEX);
-                    timestamp[ctr] = cursorImages.getLong(THUMBNAIL_DATE_MODIFIED_INDEX);
-                    thumbnailIds[ctr] = Utils.Crc64Long(cursorImages.getString(THUMBNAIL_DATA_INDEX));
-                    ++ctr;
+                    break;
                 }
+                ids[ctr] = cursorImages.getLong(THUMBNAIL_ID_INDEX);
+                timestamp[ctr] = cursorImages.getLong(THUMBNAIL_DATE_MODIFIED_INDEX);
+                thumbnailIds[ctr] = Utils.Crc64Long(cursorImages.getString(THUMBNAIL_DATA_INDEX));
+                orientation[ctr] = cursorImages.getInt(THUMBNAIL_ORIENTATION_INDEX);
+                ++ctr;
             } while (cursorImages.moveToNext());
             cursorImages.close();
+            list.ids = ids;
+            list.thumbids = thumbnailIds;
+            list.timestamp = timestamp;
+            list.orientation = orientation;
+        }
+        if (sList == null) {
+            sList = list;
+        }
+        return list;
+    }
 
-            for (int i = 0; i < size; ++i) {
-                if (Thread.interrupted()) {
-                    return;
-                }
-                final long id = ids[i];
-                final long timeModifiedInSec = timestamp[i];
-                final long thumbnailId = thumbnailIds[i];
-                if (!thumbnailCache.isDataAvailable(thumbnailId, timeModifiedInSec * 1000)) {
-                    buildThumbnailForId(context, thumbnailCache, thumbnailId, id, false, DEFAULT_THUMBNAIL_WIDTH,
-                            DEFAULT_THUMBNAIL_HEIGHT);
-                }
+    private static final byte[] queryThumbnail(final Context context, final long thumbId, final long origId, final boolean isVideo,
+            final DiskCache thumbnailCache, final long timestamp) {
+        if (!((Gallery) context).isPaused()) {
+            final Thread thumbnailThread = THUMBNAIL_THREAD.getAndSet(null);
+            if (thumbnailThread != null) {
+                thumbnailThread.interrupt();
+            }
+        }
+        byte[] bitmap = thumbnailCache.get(thumbId, timestamp);
+        if (bitmap == null) {
+            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
+            final long time = SystemClock.uptimeMillis();
+            bitmap = buildThumbnailForId(context, thumbnailCache, thumbId, origId, isVideo, DEFAULT_THUMBNAIL_WIDTH,
+                    DEFAULT_THUMBNAIL_HEIGHT);
+            Log.i(TAG, "Built thumbnail and screennail for " + origId + " in " + (SystemClock.uptimeMillis() - time));
+            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+        }
+        return bitmap;
+    }
+
+    private static final void buildThumbnails(final Context context) {
+        Log.i(TAG, "Preparing DiskCache for all thumbnails.");
+        ImageList list = getImageList(context);
+        final int size = (list.ids == null) ? 0 : list.ids.length;
+        final long[] ids = list.ids;
+        final long[] timestamp = list.timestamp;
+        final long[] thumbnailIds = list.thumbids;
+        final DiskCache thumbnailCache = LocalDataSource.sThumbnailCache;
+        for (int i = 0; i < size; ++i) {
+            if (Thread.interrupted()) {
+                return;
+            }
+            final long id = ids[i];
+            final long timeModifiedInSec = timestamp[i];
+            final long thumbnailId = thumbnailIds[i];
+            if (!thumbnailCache.isDataAvailable(thumbnailId, timeModifiedInSec * 1000)) {
+                buildThumbnailForId(context, thumbnailCache, thumbnailId, id, false, DEFAULT_THUMBNAIL_WIDTH,
+                        DEFAULT_THUMBNAIL_HEIGHT);
             }
         }
         Log.i(TAG, "DiskCache ready for all thumbnails.");
     }
 
-    private static byte[] buildThumbnailForId(final Context context, final DiskCache thumbnailCache, final long thumbId,
+    private static final byte[] buildThumbnailForId(final Context context, final DiskCache thumbnailCache, final long thumbId,
             final long origId, final boolean isVideo, final int thumbnailWidth, final int thumbnailHeight) {
         if (origId == Shared.INVALID) {
             return null;
@@ -537,7 +566,21 @@ public final class CacheService extends IntentService {
                     return null;
                 }
             } else {
-                // TODO: We need to generate video thumbnails if it is not eclair
+                Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
+                new Thread() {
+                    public void run() {
+                        try {
+                            Thread.sleep(5000);
+                        } catch (InterruptedException e) {
+                            ;
+                        }
+                        try {
+                            MediaStore.Video.Thumbnails.cancelThumbnailRequest(context.getContentResolver(), origId);
+                        } catch (Exception e) {
+                            ;
+                        }
+                    }
+                }.start();
                 bitmap = MediaStore.Video.Thumbnails.getThumbnail(context.getContentResolver(), origId,
                         MediaStore.Video.Thumbnails.MICRO_KIND, null);
             }
@@ -552,7 +595,7 @@ public final class CacheService extends IntentService {
         }
     }
 
-    public static byte[] writeBitmapToCache(final DiskCache thumbnailCache, final long thumbId, final long origId,
+    public static final byte[] writeBitmapToCache(final DiskCache thumbnailCache, final long thumbId, final long origId,
             final Bitmap bitmap, final int thumbnailWidth, final int thumbnailHeight) {
         final int width = bitmap.getWidth();
         final int height = bitmap.getHeight();
@@ -651,23 +694,23 @@ public final class CacheService extends IntentService {
         if (intent.getBooleanExtra("checkthumbnails", false)) {
             startNewThumbnailThread(this);
         } else {
-            Thread existingThread = THUMBNAIL_THREAD.getAndSet(null);
+            final Thread existingThread = THUMBNAIL_THREAD.getAndSet(null);
             if (existingThread != null) {
                 existingThread.interrupt();
             }
         }
     }
 
-    private static void putLocaleForAlbumCache(Locale locale) {
-        ByteArrayOutputStream bos = new ByteArrayOutputStream();
-        DataOutputStream dos = new DataOutputStream(bos);
+    private static final void putLocaleForAlbumCache(final Locale locale) {
+        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        final DataOutputStream dos = new DataOutputStream(bos);
         try {
             Utils.writeUTF(dos, locale.getCountry());
             Utils.writeUTF(dos, locale.getLanguage());
             Utils.writeUTF(dos, locale.getVariant());
             dos.flush();
             bos.flush();
-            byte[] data = bos.toByteArray();
+            final byte[] data = bos.toByteArray();
             sAlbumCache.put(ALBUM_CACHE_LOCALE_INDEX, data);
             sAlbumCache.flush();
             dos.close();
@@ -679,8 +722,8 @@ public final class CacheService extends IntentService {
         }
     }
 
-    private static Locale getLocaleForAlbumCache() {
-        byte[] data = sAlbumCache.get(ALBUM_CACHE_LOCALE_INDEX, 0);
+    private static final Locale getLocaleForAlbumCache() {
+        final byte[] data = sAlbumCache.get(ALBUM_CACHE_LOCALE_INDEX, 0);
         if (data != null && data.length > 0) {
             ByteArrayInputStream bis = new ByteArrayInputStream(data);
             DataInputStream dis = new DataInputStream(bis);
@@ -694,7 +737,7 @@ public final class CacheService extends IntentService {
                 String variant = Utils.readUTF(dis);
                 if (variant == null)
                     variant = "";
-                Locale locale = new Locale(language, country, variant);
+                final Locale locale = new Locale(language, country, variant);
                 dis.close();
                 bis.close();
                 return locale;
@@ -707,9 +750,9 @@ public final class CacheService extends IntentService {
         return null;
     }
 
-    private static void restartThread(final AtomicReference<Thread> threadRef, String name, final Runnable action) {
+    private static final void restartThread(final AtomicReference<Thread> threadRef, final String name, final Runnable action) {
         // Create a new thread.
-        Thread newThread = new Thread() {
+        final Thread newThread = new Thread() {
             public void run() {
                 try {
                     action.run();
@@ -722,13 +765,13 @@ public final class CacheService extends IntentService {
         newThread.start();
 
         // Interrupt any existing thread.
-        Thread existingThread = threadRef.getAndSet(newThread);
+        final Thread existingThread = threadRef.getAndSet(newThread);
         if (existingThread != null) {
             existingThread.interrupt();
         }
     }
 
-    public static void startNewThumbnailThread(final Context context) {
+    public static final void startNewThumbnailThread(final Context context) {
         restartThread(THUMBNAIL_THREAD, "ThumbnailRefresh", new Runnable() {
             public void run() {
                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
@@ -759,28 +802,28 @@ public final class CacheService extends IntentService {
         });
     }
 
-    private static final byte[] concat(byte[] A, byte[] B) {
-        byte[] C = (byte[]) new byte[A.length + B.length];
+    private static final byte[] concat(final byte[] A, final byte[] B) {
+        final byte[] C = (byte[]) new byte[A.length + B.length];
         System.arraycopy(A, 0, C, 0, A.length);
         System.arraycopy(B, 0, C, A.length, B.length);
         return C;
     }
 
-    private static final long[] toLongArray(byte[] data) {
-        ByteBuffer bBuffer = ByteBuffer.wrap(data);
-        LongBuffer lBuffer = bBuffer.asLongBuffer();
-        int numLongs = lBuffer.capacity();
-        long[] retVal = new long[numLongs];
+    private static final long[] toLongArray(final byte[] data) {
+        final ByteBuffer bBuffer = ByteBuffer.wrap(data);
+        final LongBuffer lBuffer = bBuffer.asLongBuffer();
+        final int numLongs = lBuffer.capacity();
+        final long[] retVal = new long[numLongs];
         for (int i = 0; i < numLongs; ++i) {
             retVal[i] = lBuffer.get(i);
         }
         return retVal;
     }
 
-    private static byte[] longToByteArray(long l) {
-        byte[] bArray = new byte[8];
-        ByteBuffer bBuffer = ByteBuffer.wrap(bArray);
-        LongBuffer lBuffer = bBuffer.asLongBuffer();
+    private static final byte[] longToByteArray(final long l) {
+        final byte[] bArray = new byte[8];
+        final ByteBuffer bBuffer = ByteBuffer.wrap(bArray);
+        final LongBuffer lBuffer = bBuffer.asLongBuffer();
         lBuffer.put(0, l);
         return bArray;
     }
@@ -789,10 +832,12 @@ public final class CacheService extends IntentService {
         // First we build the album cache.
         // This is the meta-data about the albums / buckets on the SD card.
         Log.i(TAG, "Refreshing cache.");
+        int priority = Process.getThreadPriority(Process.myTid());
+        Process.setThreadPriority(Process.THREAD_PRIORITY_MORE_FAVORABLE);
         sAlbumCache.deleteAll();
         putLocaleForAlbumCache(Locale.getDefault());
-        
-        ArrayList<MediaSet> sets = new ArrayList<MediaSet>();
+
+        final ArrayList<MediaSet> sets = new ArrayList<MediaSet>();
         LongSparseArray<MediaSet> acceleratedSets = new LongSparseArray<MediaSet>();
         Log.i(TAG, "Building albums.");
         final Uri uriImages = Images.Media.EXTERNAL_CONTENT_URI.buildUpon().appendQueryParameter("distinct", "true").build();
@@ -833,13 +878,13 @@ public final class CacheService extends IntentService {
             sortCursor.close();
         }
 
-        byte[] data = new byte[] { 1 };
-        sAlbumCache.put(ALBUM_CACHE_INCOMPLETE_INDEX, data);
+        sAlbumCache.put(ALBUM_CACHE_INCOMPLETE_INDEX, sDummyData);
         writeSetsToCache(sets);
         Log.i(TAG, "Done building albums.");
         // Now we must cache the items contained in every album / bucket.
         populateMediaItemsForSets(context, sets, acceleratedSets, false);
         sAlbumCache.delete(ALBUM_CACHE_INCOMPLETE_INDEX);
+        Process.setThreadPriority(priority);
         if (QUEUE_DIRTY_ALL) {
             QUEUE_DIRTY_ALL = false;
             refresh(context);
@@ -847,15 +892,15 @@ public final class CacheService extends IntentService {
     }
 
     private final static void refreshDirtySets(final Context context) {
-        byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
+        final byte[] existingData = sAlbumCache.get(ALBUM_CACHE_DIRTY_BUCKET_INDEX, 0);
         if (existingData != null && existingData.length > 0) {
-            long[] ids = toLongArray(existingData);
-            int numIds = ids.length;
+            final long[] ids = toLongArray(existingData);
+            final int numIds = ids.length;
             if (numIds > 0) {
-                ArrayList<MediaSet> sets = new ArrayList<MediaSet>(numIds);
-                LongSparseArray<MediaSet> acceleratedSets = new LongSparseArray<MediaSet>(numIds);
+                final ArrayList<MediaSet> sets = new ArrayList<MediaSet>(numIds);
+                final LongSparseArray<MediaSet> acceleratedSets = new LongSparseArray<MediaSet>(numIds);
                 for (int i = 0; i < numIds; ++i) {
-                    MediaSet set = new MediaSet();
+                    final MediaSet set = new MediaSet();
                     set.mId = ids[i];
                     sets.add(set);
                     acceleratedSets.put(set.mId, set);
@@ -899,37 +944,38 @@ public final class CacheService extends IntentService {
 
         final Cursor cursorImages = cr.query(uriImages, PROJECTION_IMAGES, whereClause, null, DEFAULT_IMAGE_SORT_ORDER);
         final Cursor cursorVideos = cr.query(uriVideos, PROJECTION_VIDEOS, whereClause, null, DEFAULT_VIDEO_SORT_ORDER);
-        Cursor[] cursors = new Cursor[2];
+        final Cursor[] cursors = new Cursor[2];
         cursors[0] = cursorImages;
         cursors[1] = cursorVideos;
         final SortCursor sortCursor = new SortCursor(cursors, Images.ImageColumns.DATE_TAKEN, SortCursor.TYPE_NUMERIC, true);
         if (Thread.interrupted()) {
             return;
         }
-
+        
         if (sortCursor != null && sortCursor.moveToFirst()) {
-            int count = sortCursor.getCount();
-            int numSets = sets.size();
-            int approximateCountPerSet = count / numSets;
+            final int count = sortCursor.getCount();
+            final int numSets = sets.size();
+            final int approximateCountPerSet = count / numSets;
             for (int i = 0; i < numSets; ++i) {
-                MediaSet set = sets.get(i);
+                final MediaSet set = sets.get(i);
+                set.getItems().clear();
                 set.setNumExpectedItems(approximateCountPerSet);
             }
             do {
                 if (Thread.interrupted()) {
                     return;
                 }
-                MediaItem item = new MediaItem();
-                boolean isVideo = (sortCursor.getCurrentCursorIndex() == 1);
+                final MediaItem item = new MediaItem();
+                final boolean isVideo = (sortCursor.getCurrentCursorIndex() == 1);
                 if (isVideo) {
-                    populateVideoItemFromCursor(item, cr, sortCursor, BASE_CONTENT_STRING_VIDEOS);
+                    populateVideoItemFromCursor(item, cr, sortCursor, CacheService.BASE_CONTENT_STRING_VIDEOS);
                 } else {
-                    populateMediaItemFromCursor(item, cr, sortCursor, BASE_CONTENT_STRING_IMAGES);
+                    populateMediaItemFromCursor(item, cr, sortCursor, CacheService.BASE_CONTENT_STRING_IMAGES);
                 }
-                long setId = sortCursor.getLong(MEDIA_BUCKET_ID_INDEX);
-                MediaSet set = findSet(setId, acceleratedSets);
+                final long setId = sortCursor.getLong(MEDIA_BUCKET_ID_INDEX);
+                final MediaSet set = findSet(setId, acceleratedSets);
                 if (set != null) {
-                    set.addItem(item);
+                    set.getItems().add(item);
                 }
             } while (sortCursor.moveToNext());
         }
@@ -985,8 +1031,8 @@ public final class CacheService extends IntentService {
         final ByteArrayOutputStream bos = new ByteArrayOutputStream();
         final DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(bos, 256));
         try {
-            ArrayList<MediaItem> items = set.getItems();
-            int numItems = set.getNumItems();
+            final ArrayList<MediaItem> items = set.getItems();
+            final int numItems = items.size();
             dos.writeInt(numItems);
             dos.writeLong(set.mMinTimestamp);
             dos.writeLong(set.mMaxTimestamp);
@@ -1020,7 +1066,7 @@ public final class CacheService extends IntentService {
         }
     }
 
-    private static final MediaSet findSet(long id, LongSparseArray<MediaSet> acceleratedTable) {
+    private static final MediaSet findSet(final long id, final LongSparseArray<MediaSet> acceleratedTable) {
         // This is the accelerated lookup table for the MediaSet based on set id.
         return acceleratedTable.get(id);
     }

--- /dev/null
+++ b/src/com/cooliris/cache/ImageList.java
@@ -0,0 +1,8 @@
+package com.cooliris.cache;
+
+public class ImageList {
+    public long ids[];
+    public long thumbids[];
+    public long timestamp[];
+    public int orientation[];
+}

--- /dev/null
+++ b/src/com/cooliris/media/ActiveWallpaper.java
@@ -0,0 +1,17 @@
+package com.cooliris.media;
+
+import com.cooliris.wallpaper.RandomDataSource;
+import com.cooliris.wallpaper.Slideshow;
+
+import android.app.*;
+import android.os.Bundle;
+
+public class ActiveWallpaper extends Activity {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Slideshow slideshow = new Slideshow(this);
+        slideshow.setDataSource(new RandomDataSource());
+        setContentView(slideshow);
+    }
+}

--- a/src/com/cooliris/media/AdaptiveBackgroundTexture.java
+++ b/src/com/cooliris/media/AdaptiveBackgroundTexture.java
@@ -76,8 +76,8 @@ public final class AdaptiveBackgroundTexture extends Texture {
         int sourceHeight = source.getHeight();
         int destWidth = mWidth;
         int destHeight = mHeight;
-        float fitX = (float) sourceWidth / destWidth;  // CR: cast destWidth to float as well to be clean; no space after the cast.
-        float fitY = (float) sourceHeight / destHeight;
+        float fitX = (float)sourceWidth / (float)destWidth;
+        float fitY = (float)sourceHeight / (float)destHeight;
         float scale;
         int cropX;
         int cropY;
@@ -86,10 +86,10 @@ public final class AdaptiveBackgroundTexture extends Texture {
         if (fitX < fitY) {
             // Full width, partial height.
             cropWidth = sourceWidth;
-            cropHeight = (int) (destHeight * fitX);  // CR: no space after the cast.
+            cropHeight = (int)(destHeight * fitX);
             cropX = 0;
             cropY = (sourceHeight - cropHeight) / 2;
-            scale = 1f / fitX;  // CR: i think 1.0f is clearer than 1f.
+            scale = 1.0f / fitX;
         } else {
             // Full height, partial or full width.
             cropWidth = (int) (destHeight * fitY);

--- a/src/com/cooliris/media/ArrayUtils.java
+++ b/src/com/cooliris/media/ArrayUtils.java
@@ -21,7 +21,7 @@ public final class ArrayUtils {
         int firstListSize = firstList.size();
         for (int i = 0; i < firstListSize; ++i) {
             MediaItem firstListItem = firstList.get(i);
-            MediaItem hashItem = hash[firstListItem.hashCode() & mask];
+            MediaItem hashItem = (hash != null) ? hash[firstListItem.hashCode() & mask] : null;
             if (hashItem != null && ((hashItem.mId != Shared.INVALID && hashItem.mId == firstListItem.mId) || contains(secondList, firstListItem))) {
                 intersectionList.add(firstListItem);
                 if (--maxSize == 0) {

--- a/src/com/cooliris/media/BackgroundLayer.java
+++ b/src/com/cooliris/media/BackgroundLayer.java
@@ -9,7 +9,7 @@ public class BackgroundLayer extends Layer {
     private static final String TAG = "AdaptiveBackground";
     private final GridLayer mGridLayer;
     private CrossFadingTexture mBackground;
-    private static final int MAX_ADAPTIVES_TO_KEEP_IN_MEMORY = 8;
+    private static final int MAX_ADAPTIVES_TO_KEEP_IN_MEMORY = 16;
 
     private final HashMap<Texture, AdaptiveBackgroundTexture> mCacheAdaptiveTexture = new HashMap<Texture, AdaptiveBackgroundTexture>();
     private int mCount;
@@ -43,7 +43,7 @@ public class BackgroundLayer extends Layer {
         int cameraPosition = (int) mGridLayer.getScrollPosition();
         final int backgroundSpacing = mBackgroundBlitWidth - mBackgroundOverlap;
         cameraPosition = (int) ((cameraPosition / backgroundSpacing) * backgroundSpacing);
-        final DisplayItem displayItem = mGridLayer.getDisplayItemForScrollPosition(cameraPosition);
+        final DisplayItem displayItem = mGridLayer.getRepresentativeDisplayItem();
         if (displayItem != null) {
             mBackground.setTexture(getAdaptive(view, displayItem));
         }
@@ -76,13 +76,15 @@ public class BackgroundLayer extends Layer {
     @Override
     public void renderOpaque(RenderView view, GL11 gl) {
         gl.glClear(GL11.GL_COLOR_BUFFER_BIT);
-        mFallbackBackground = view.getResource(R.drawable.default_background, false);
-        view.loadTexture(mFallbackBackground);
+        if (mFallbackBackground == null) {
+            mFallbackBackground = view.getResource(R.drawable.default_background, false);
+            view.loadTexture(mFallbackBackground);
+        }
     }
 
     @Override
     public void renderBlended(RenderView view, GL11 gl) {
-        if (mBackground == null)
+        if (mBackground == null || mFallbackBackground == null)
             return;
         gl.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
         gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
@@ -90,6 +92,11 @@ public class BackgroundLayer extends Layer {
         boolean bind = anchorTexture.bind(view, gl);
         if (!bind) {
             view.bind(mFallbackBackground);
+        } else {
+            Texture texture = anchorTexture.getTexture();
+            if (texture.isLoaded()) {
+                mFallbackBackground = texture;
+            }
         }
         
         // We stitch this crossfading texture, and to cover all cases of overlap we need to perform 3 draws.
@@ -122,6 +129,7 @@ public class BackgroundLayer extends Layer {
     public void clear() {
         clearCache();
         mBackground = null;
+        mFallbackBackground = null;
     }
 
     public void clearCache() {

--- a/src/com/cooliris/media/DiskCache.java
+++ b/src/com/cooliris/media/DiskCache.java
@@ -45,10 +45,6 @@ public final class DiskCache {
         shutdown();
     }
 
-    public void load() {
-        loadIndex();
-    }
-
     public byte[] get(long key, long timestamp) {
         // Look up the record for the given key.
         Record record = null;
@@ -58,7 +54,6 @@ public final class DiskCache {
         if (record != null) {
             // Read the chunk from the file.
             if (record.timestamp < timestamp && timestamp < System.currentTimeMillis()) {
-                Log.i(TAG, "Old copy: CacheTimestamp " + record.timestamp + " new timestamp " + timestamp);
                 return null;
             }
             try {
@@ -85,9 +80,10 @@ public final class DiskCache {
             return false;
         }
         if (record.timestamp < timestamp && timestamp < System.currentTimeMillis()) {
-            Log.i(TAG, "Old copy: CacheTimestamp " + record.timestamp + " new timestamp " + timestamp);
             return false;
         }
+        if (record.size == 0)
+            return false;
         return true;
     }
 

--- a/src/com/cooliris/media/FloatUtils.java
+++ b/src/com/cooliris/media/FloatUtils.java
@@ -127,4 +127,11 @@ public class FloatUtils {
             }
         }
     }
+
+    public static final float max(float scaleX, float scaleY) {
+        if (scaleX > scaleY)
+            return scaleX;
+        else
+            return scaleY;
+    }
 }

--- a/src/com/cooliris/media/Gallery.java
+++ b/src/com/cooliris/media/Gallery.java
@@ -12,6 +12,7 @@ import android.graphics.Bitmap;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
+import android.provider.MediaStore.Images;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.KeyEvent;
@@ -19,14 +20,16 @@ import android.widget.Toast;
 import android.media.MediaScannerConnection;
 
 import com.cooliris.cache.CacheService;
+import com.cooliris.wallpaper.RandomDataSource;
+import com.cooliris.wallpaper.Slideshow;
 
 public final class Gallery extends Activity {
     public static final TimeZone CURRENT_TIME_ZONE = TimeZone.getDefault();
-    public static float PIXEL_DENSITY = 1.0f;
-    public static int DENSITY_DPI = DisplayMetrics.DENSITY_DEFAULT;
+    public static float PIXEL_DENSITY = 0.0f;
     public static boolean NEEDS_REFRESH = true;
-    public static final int CROP_MSG_INTERNAL = 100;
+
     private static final String TAG = "Gallery";
+    public static final int CROP_MSG_INTERNAL = 100;
     private static final int CROP_MSG = 10;
     private RenderView mRenderView = null;
     private GridLayer mGridLayer;
@@ -34,16 +37,25 @@ public final class Gallery extends Activity {
     private ReverseGeocoder mReverseGeocoder;
     private boolean mPause;
     private MediaScannerConnection mConnection;
+    private static final boolean TEST_WALLPAPER = false;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        if (TEST_WALLPAPER || (isViewIntent() && getIntent().getData().equals(Images.Media.EXTERNAL_CONTENT_URI))) {
+            Slideshow slideshow = new Slideshow(this);
+            slideshow.setDataSource(new RandomDataSource());
+            setContentView(slideshow);
+            return;
+        }
         boolean isCacheReady = CacheService.isCacheReady(false);
         CacheService.startCache(this, false);
+        if (PIXEL_DENSITY == 0.0f) {
+            DisplayMetrics metrics = new DisplayMetrics();
+            getWindowManager().getDefaultDisplay().getMetrics(metrics);
+            PIXEL_DENSITY = metrics.density;
+        }
         mReverseGeocoder = new ReverseGeocoder(this);
-        DisplayMetrics metrics = new DisplayMetrics();
-        getWindowManager().getDefaultDisplay().getMetrics(metrics);
-        PIXEL_DENSITY = metrics.density;
         mRenderView = new RenderView(this);
         mGridLayer = new GridLayer(this, (int) (96.0f * PIXEL_DENSITY), (int) (72.0f * PIXEL_DENSITY), new GridLayoutInterface(4),
                 mRenderView);
@@ -99,7 +111,9 @@ public final class Gallery extends Activity {
             Uri uri = getIntent().getData();
             boolean slideshow = getIntent().getBooleanExtra("slideshow", false);
             SingleDataSource localDataSource = new SingleDataSource(this, uri.toString(), slideshow);
-            mGridLayer.setDataSource(localDataSource);
+            PicasaDataSource picasaDataSource = new PicasaDataSource(this);
+            ConcatenatedDataSource combinedDataSource = new ConcatenatedDataSource(localDataSource, picasaDataSource);
+            mGridLayer.setDataSource(combinedDataSource);
             mGridLayer.setViewIntent(true, Utils.getBucketNameFromUri(uri));
             if (SingleDataSource.isSingleImageMode(uri.toString())) {
                 mGridLayer.setSingleImage(false);
@@ -133,7 +147,8 @@ public final class Gallery extends Activity {
     @Override
     public void onResume() {
         super.onResume();
-        mRenderView.onResume();
+        if (mRenderView != null)
+            mRenderView.onResume();
         if (NEEDS_REFRESH) {
             NEEDS_REFRESH = false;
             CacheService.markDirtyImmediate(LocalDataSource.CAMERA_BUCKET_ID);
@@ -146,7 +161,8 @@ public final class Gallery extends Activity {
     @Override
     public void onPause() {
         super.onPause();
-        mRenderView.onPause();
+        if (mRenderView != null)
+            mRenderView.onPause();
         mPause = true;
     }
 
@@ -172,8 +188,8 @@ public final class Gallery extends Activity {
     public void onDestroy() {
         // Force GLThread to exit.
         setContentView(R.layout.main);
-        DataSource dataSource = mGridLayer.getDataSource();
         if (mGridLayer != null) {
+            DataSource dataSource = mGridLayer.getDataSource();
             if (dataSource != null) {
                 dataSource.shutdown();
             }
@@ -181,8 +197,10 @@ public final class Gallery extends Activity {
         }
         if (mReverseGeocoder != null)
             mReverseGeocoder.shutdown();
-        mRenderView.shutdown();
-        mRenderView = null;
+        if (mRenderView != null) {
+            mRenderView.shutdown();
+            mRenderView = null;
+        }
         mGridLayer = null;
         super.onDestroy();
         Log.i(TAG, "onDestroy");
@@ -194,13 +212,18 @@ public final class Gallery extends Activity {
         if (mGridLayer != null) {
             mGridLayer.markDirty(30);
         }
-        mRenderView.requestRender();
+        if (mRenderView != null)
+            mRenderView.requestRender();
         Log.i(TAG, "onConfigurationChanged");
     }
 
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
-        return mRenderView.onKeyDown(keyCode, event) || super.onKeyDown(keyCode, event);
+        if (mRenderView != null) {
+            return mRenderView.onKeyDown(keyCode, event) || super.onKeyDown(keyCode, event);
+        } else {
+            return super.onKeyDown(keyCode, event);
+        }
     }
 
     private boolean isPickIntent() {
@@ -293,7 +316,7 @@ public final class Gallery extends Activity {
                         public void onScanCompleted(String path, Uri uri) {
                             shutdown(uri.toString());
                         }
-                        
+
                         public void shutdown(String uri) {
                             dialog.dismiss();
                             performReturn(myExtras, uri.toString());
@@ -319,7 +342,7 @@ public final class Gallery extends Activity {
             Bitmap bitmap = null;
             try {
                 bitmap = UriTexture.createFromUri(this, contentUri, 1024, 1024, 0, null);
-            } catch (IOException e) { 
+            } catch (IOException e) {
                 ;
             } catch (URISyntaxException e) {
                 ;

--- a/src/com/cooliris/media/GridCameraManager.java
+++ b/src/com/cooliris/media/GridCameraManager.java
@@ -1,23 +1,25 @@
 package com.cooliris.media;
 
 public final class GridCameraManager {
-    private GridCamera mCamera;
-    private ConcurrentPool<Vector3f> mPool;
-
-    public GridCameraManager(GridCamera camera) {
-        mCamera = camera;
-        Vector3f[] vectorPool = new Vector3f[128];
+    private final GridCamera mCamera;
+    private static final Pool<Vector3f> sPool;
+    static {
+        final Vector3f[] vectorPool = new Vector3f[128];
         int length = vectorPool.length;
         for (int i = 0; i < length; ++i) {
             vectorPool[i] = new Vector3f();
         }
-        mPool = new ConcurrentPool<Vector3f>(vectorPool);
+        sPool = new Pool<Vector3f>(vectorPool);
+    }
+
+    public GridCameraManager(final GridCamera camera) {
+        mCamera = camera;
     }
 
     public void centerCameraForSlot(LayoutInterface layout, int slotIndex, float baseConvergence, Vector3f deltaAnchorPositionIn,
             int selectedSlotIndex, float zoomValue, float imageTheta, int state) {
         final GridCamera camera = mCamera;
-        final ConcurrentPool<Vector3f> pool = mPool;
+        final Pool<Vector3f> pool = sPool;
         synchronized (camera) {
             final boolean zoomin = (selectedSlotIndex != Shared.INVALID);
             final int theta = (int) imageTheta;
@@ -61,16 +63,16 @@ public final class GridCameraManager {
      */
     public boolean constrainCameraForSlot(LayoutInterface layout, int slotIndex, Vector3f deltaAnchorPositionIn,
             float currentFocusItemWidth, float currentFocusItemHeight) {
-        GridCamera camera = mCamera;
-        ConcurrentPool<Vector3f> pool = mPool;
+        final GridCamera camera = mCamera;
+        final Pool<Vector3f> pool = sPool;
         boolean retVal = false;
         synchronized (camera) {
-            Vector3f position = pool.create();
-            Vector3f deltaAnchorPosition = pool.create();
-            Vector3f topLeft = pool.create();
-            Vector3f bottomRight = pool.create();
-            Vector3f imgTopLeft = pool.create();
-            Vector3f imgBottomRight = pool.create();
+            final Vector3f position = pool.create();
+            final Vector3f deltaAnchorPosition = pool.create();
+            final Vector3f topLeft = pool.create();
+            final Vector3f bottomRight = pool.create();
+            final Vector3f imgTopLeft = pool.create();
+            final Vector3f imgBottomRight = pool.create();
 
             try {
                 if (slotIndex >= 0) {
@@ -120,7 +122,7 @@ public final class GridCameraManager {
     public void computeVisibleRange(MediaFeed feed, LayoutInterface layout, Vector3f deltaAnchorPositionIn,
             IndexRange outVisibleRange, IndexRange outBufferedVisibleRange, IndexRange outCompleteRange, int state) {
         GridCamera camera = mCamera;
-        ConcurrentPool<Vector3f> pool = mPool;
+        Pool<Vector3f> pool = sPool;
         float offset = (camera.mLookAtX * camera.mScale);
         int itemWidth = camera.mItemWidth;
         float maxIncrement = camera.mWidth * 0.5f + itemWidth;
@@ -223,8 +225,8 @@ public final class GridCameraManager {
 
     public static final float getFillScreenZoomValue(GridCamera camera, Pool<Vector3f> pool, float currentFocusItemWidth,
             float currentFocusItemHeight) {
-        Vector3f topLeft = pool.create();
-        Vector3f bottomRight = pool.create();
+        final Vector3f topLeft = pool.create();
+        final Vector3f bottomRight = pool.create();
         float potentialZoomValue = 1.0f;
         try {
             camera.convertToCameraSpace(0, 0, 0, topLeft);

--- a/src/com/cooliris/media/GridDrawManager.java
+++ b/src/com/cooliris/media/GridDrawManager.java
@@ -21,16 +21,16 @@ public final class GridDrawManager {
     public static final int PASS_LOCATION_LABEL = 8;
     public static final int PASS_MEDIASET_SOURCE_LABEL = 9;
 
-    private MediaItemTexture.Config mThumbnailConfig = new MediaItemTexture.Config();
-    private DisplayItem[] mDisplayItems;
-    private DisplaySlot[] mDisplaySlots;
-    private DisplayList mDisplayList;
-    private GridCamera mCamera;
+    private static final MediaItemTexture.Config sThumbnailConfig = new MediaItemTexture.Config();
+    private final DisplayItem[] mDisplayItems;
+    private final DisplaySlot[] mDisplaySlots;
+    private final DisplayList mDisplayList;
+    private final GridCamera mCamera;
+    private final GridDrawables mDrawables;
     private IndexRange mBufferedVisibleRange;
     private IndexRange mVisibleRange;
     private int mSelectedSlot;
     private int mCurrentFocusSlot;
-    private GridDrawables mDrawables;
     private DisplayItem[] mItemsDrawn;
     private int mDrawnCounter;
     private float mTargetFocusMixRatio = 0.0f;
@@ -41,7 +41,7 @@ public final class GridDrawManager {
     private boolean mCurrentFocusIsPressed;
     private final Texture mNoItemsTexture;
 
-    private Comparator<DisplayItem> mDisplayItemComparator = new Comparator<DisplayItem>() {
+    private static final Comparator<DisplayItem> sDisplayItemComparator = new Comparator<DisplayItem>() {
         public int compare(DisplayItem a, DisplayItem b) {
             if (a == null || b == null) {
                 return 0;
@@ -59,8 +59,8 @@ public final class GridDrawManager {
 
     public GridDrawManager(Context context, GridCamera camera, GridDrawables drawables, DisplayList displayList,
             DisplayItem[] displayItems, DisplaySlot[] displaySlots) {
-        mThumbnailConfig.thumbnailWidth = 128;
-        mThumbnailConfig.thumbnailHeight = 96;
+        sThumbnailConfig.thumbnailWidth = 128;
+        sThumbnailConfig.thumbnailHeight = 96;
         mDisplayItems = displayItems;
         mDisplaySlots = displaySlots;
         mDisplayList = displayList;
@@ -96,21 +96,22 @@ public final class GridDrawManager {
     }
 
     public void drawThumbnails(RenderView view, GL11 gl, int state) {
-        GridDrawables drawables = mDrawables;
-        DisplayList displayList = mDisplayList;
-        DisplayItem[] displayItems = mDisplayItems;
-        int firstBufferedVisibleSlot = mBufferedVisibleRange.begin;
-        int lastBufferedVisibleSlot = mBufferedVisibleRange.end;
-        int firstVisibleSlot = mVisibleRange.begin;
-        int lastVisibleSlot = mVisibleRange.end;
-        int selectedSlotIndex = mSelectedSlot;
-        int currentFocusSlot = mCurrentFocusSlot;
-        DisplayItem[] itemsDrawn = mItemsDrawn;
+        final GridDrawables drawables = mDrawables;
+        final DisplayList displayList = mDisplayList;
+        final DisplayItem[] displayItems = mDisplayItems;
+        final int firstBufferedVisibleSlot = mBufferedVisibleRange.begin;
+        final int lastBufferedVisibleSlot = mBufferedVisibleRange.end;
+        final int firstVisibleSlot = mVisibleRange.begin;
+        final int lastVisibleSlot = mVisibleRange.end;
+        final int selectedSlotIndex = mSelectedSlot;
+        final int currentFocusSlot = mCurrentFocusSlot;
+        final DisplayItem[] itemsDrawn = mItemsDrawn;
         itemsDrawn[0] = null; // No items drawn yet.
         int drawnCounter = 0;
-        GridQuad grid = drawables.mGrid;
+        final GridQuad grid = GridDrawables.sGrid;
         grid.bindArrays(gl);
         int numTexturesQueued = 0;
+        Context context = view.getContext();
         for (int itrSlotIndex = firstBufferedVisibleSlot; itrSlotIndex <= lastBufferedVisibleSlot; ++itrSlotIndex) {
             int index = itrSlotIndex;
             boolean priority = !(index < firstVisibleSlot || index > lastVisibleSlot);
@@ -120,7 +121,7 @@ public final class GridDrawManager {
                 if (displayItem == null) {
                     continue;
                 } else {
-                    Texture texture = displayItem.getThumbnailImage(view.getContext(), mThumbnailConfig);
+                    Texture texture = displayItem.getThumbnailImage(context, sThumbnailConfig);
                     if (texture != null && texture.isLoaded() == false) {
                         startSlotIndex = j;
                         break;
@@ -136,13 +137,13 @@ public final class GridDrawManager {
                     if (selectedSlotIndex != Shared.INVALID && (index <= selectedSlotIndex - 2 || index >= selectedSlotIndex + 2)) {
                         displayItem.clearScreennailImage();
                     }
-                    Texture texture = displayItem.getThumbnailImage(view.getContext(), mThumbnailConfig);
+                    Texture texture = displayItem.getThumbnailImage(context, sThumbnailConfig);
                     if (texture != null && !texture.isLoaded() && numTexturesQueued <= 6) {
-                        boolean isUncachedVideo = texture.isUncachedVideo();
-                        if (!isUncachedVideo)
+                        boolean isCached = texture.isCached();
+                        if (isCached)
                             view.prime(texture, priority);
                         view.bind(texture);
-                        if (priority && !isUncachedVideo)
+                        if (priority && isCached && texture.mState != Texture.STATE_ERROR)
                             ++numTexturesQueued;
                     }
                 }
@@ -164,7 +165,7 @@ public final class GridDrawManager {
                     } else {
                         displayList.setHasFocus(displayItem, false, pushDown);
                     }
-                    Texture texture = displayItem.getThumbnailImage(view.getContext(), mThumbnailConfig);
+                    Texture texture = displayItem.getThumbnailImage(view.getContext(), sThumbnailConfig);
                     if (texture != null) {
                         if ((!displayItem.isAnimating() || !texture.isLoaded())
                                 && displayItem.getStackIndex() > GridLayer.MAX_ITEMS_PER_SLOT) {
@@ -194,7 +195,6 @@ public final class GridDrawManager {
         }
         mDrawnCounter = drawnCounter;
         grid.unbindArrays(gl);
-        drawables.swapGridQuads(gl);
     }
 
     public float getFocusQuadWidth() {
@@ -255,7 +255,7 @@ public final class GridDrawManager {
                     }
                     DisplayItem displayItem = displayItems[indexInDrawnArray];
                     MediaItem item = displayItem.mItemRef;
-                    final Texture thumbnailTexture = displayItem.getThumbnailImage(view.getContext(), mThumbnailConfig);
+                    final Texture thumbnailTexture = displayItem.getThumbnailImage(view.getContext(), sThumbnailConfig);
                     Texture texture = displayItem.getScreennailImage(view.getContext());
                     if (isCameraZAnimating && (texture == null || !texture.isLoaded())) {
                         texture = thumbnailTexture;
@@ -296,11 +296,13 @@ public final class GridDrawManager {
                             mSelectedMixRatio.animateValue(1f, 0.75f, view.getFrameTime());
                         }
                     }
-                    if (!slideshowMode && skipPrevious && i == -1) {
-                        continue;
-                    }
-                    if (!skipPrevious && i == 1) {
-                        continue;
+                    if (mCamera.isAnimating()) {
+                        if (!slideshowMode && skipPrevious && i == -1) {
+                            continue;
+                        }
+                        if (!skipPrevious && i == 1) {
+                            continue;
+                        }
                     }
                     int theta = (int) displayItem.getImageTheta();
                     // If it is in slideshow mode, we draw the previous item in
@@ -332,7 +334,7 @@ public final class GridDrawManager {
                             texture = thumbnailTexture;
                             view.setAlpha(alpha * (1.0f - selectedMixRatio));
                         }
-                        GridQuad quad = drawables.mFullscreenGrid[vboIndex];
+                        GridQuad quad = GridDrawables.sFullscreenGrid[vboIndex];
                         float u = texture.getNormalizedWidth();
                         float v = texture.getNormalizedHeight();
                         float imageWidth = texture.getWidth();
@@ -373,9 +375,9 @@ public final class GridDrawManager {
                         view.setAlpha(alpha);
                         if (item.getMediaType() == MediaItem.MEDIA_TYPE_VIDEO) {
                             // The play graphic overlay.
-                            drawables.mVideoGrid.bindArrays(gl);
+                            GridDrawables.sVideoGrid.bindArrays(gl);
                             drawDisplayItem(view, gl, displayItem, drawables.mTextureVideo, PASS_VIDEO_LABEL, null, 0);
-                            drawables.mVideoGrid.unbindArrays(gl);
+                            GridDrawables.sVideoGrid.unbindArrays(gl);
                         }
                     }
                 }
@@ -395,7 +397,7 @@ public final class GridDrawManager {
         // We draw the frames around the drawn items.
         boolean currentFocusIsPressed = mCurrentFocusIsPressed;
         if (state != GridLayer.STATE_FULL_SCREEN) {
-            drawables.mFrame.bindArrays(gl);
+            GridDrawables.sFrame.bindArrays(gl);
             Texture texturePlaceHolder = (state == GridLayer.STATE_GRID_VIEW) ? drawables.mTextureGridFrame
                     : drawables.mTextureFrame;
             for (int i = firstBufferedVisibleSlot; i <= lastBufferedVisibleSlot; ++i) {
@@ -427,7 +429,7 @@ public final class GridDrawManager {
             DisplayItem[] itemsDrawn = mItemsDrawn;
             if (texture != null) {
                 if (drawnCounter > 0) {
-                    Arrays.sort(itemsDrawn, 0, drawnCounter, mDisplayItemComparator);
+                    Arrays.sort(itemsDrawn, 0, drawnCounter, sDisplayItemComparator);
                     float timeElapsedSinceGridView = gridMixRatio;
                     float timeElapsedSinceStackView = stackMixRatio;
                     for (int i = drawnCounter - 1; i >= 0; --i) {
@@ -457,14 +459,14 @@ public final class GridDrawManager {
                     }
                 }
             }
-            drawables.mFrame.unbindArrays(gl);
+            GridDrawables.sFrame.unbindArrays(gl);
             gl.glDepthFunc(GL10.GL_ALWAYS);
             if (state == GridLayer.STATE_MEDIA_SETS || state == GridLayer.STATE_TIMELINE) {
                 DisplaySlot[] displaySlots = mDisplaySlots;
-                drawables.mTextGrid.bindArrays(gl);
+                GridDrawables.sTextGrid.bindArrays(gl);
                 final float textOffsetY = 0.82f;
                 gl.glTranslatef(0.0f, -textOffsetY, 0.0f);
-                HashMap<String, StringTexture> stringTextureTable = drawables.mStringTextureTable;
+                HashMap<String, StringTexture> stringTextureTable = GridDrawables.sStringTextureTable;
                 ReverseGeocoder reverseGeocoder = ((Gallery) view.getContext()).getReverseGeocoder();
 
                 boolean itemsPresent = false;
@@ -512,7 +514,7 @@ public final class GridDrawManager {
                     }
                 }
                 if (state == GridLayer.STATE_TIMELINE) {
-                    drawables.mLocationGrid.bindArrays(gl);
+                    GridDrawables.sLocationGrid.bindArrays(gl);
                     Texture locationTexture = drawables.mTextureLocation;
                     final float yLocationLabelOffset = 0.19f;
                     for (int i = firstBufferedVisibleSlot; i <= lastBufferedVisibleSlot; ++i) {
@@ -536,9 +538,9 @@ public final class GridDrawManager {
                         }
                     }
 
-                    drawables.mLocationGrid.unbindArrays(gl);
+                    GridDrawables.sLocationGrid.unbindArrays(gl);
                 } else if (state == GridLayer.STATE_MEDIA_SETS && stackMixRatio > 0.0f) {
-                    drawables.mSourceIconGrid.bindArrays(gl);
+                    GridDrawables.sSourceIconGrid.bindArrays(gl);
                     Texture transparentTexture = drawables.mTextureTransparent;
                     for (int i = firstBufferedVisibleSlot; i <= lastBufferedVisibleSlot; ++i) {
                         DisplayItem displayItem = displayItems[(i - firstBufferedVisibleSlot) * GridLayer.MAX_ITEMS_PER_SLOT];
@@ -556,18 +558,18 @@ public final class GridDrawManager {
                             }
                         }
                     }
-                    drawables.mSourceIconGrid.unbindArrays(gl);
+                    GridDrawables.sSourceIconGrid.unbindArrays(gl);
                 }
                 gl.glTranslatef(0.0f, yLocOffset, 0.0f);
                 gl.glTranslatef(0.0f, textOffsetY, 0.0f);
-                drawables.mTextGrid.unbindArrays(gl);
+                GridDrawables.sTextGrid.unbindArrays(gl);
             }
             if (hudMode == HudLayer.MODE_SELECT && state != GridLayer.STATE_FULL_SCREEN) {
                 Texture textureSelectedOn = drawables.mTextureCheckmarkOn;
                 Texture textureSelectedOff = drawables.mTextureCheckmarkOff;
                 view.prime(textureSelectedOn, true);
                 view.prime(textureSelectedOff, true);
-                drawables.mSelectedGrid.bindArrays(gl);
+                GridDrawables.sSelectedGrid.bindArrays(gl);
                 for (int i = firstBufferedVisibleSlot; i <= lastBufferedVisibleSlot; ++i) {
                     DisplayItem displayItem = displayItems[(i - firstBufferedVisibleSlot) * GridLayer.MAX_ITEMS_PER_SLOT];
                     if (displayItem != null) {
@@ -575,9 +577,9 @@ public final class GridDrawManager {
                         drawDisplayItem(view, gl, displayItem, textureToUse, PASS_SELECTION_LABEL, null, 0);
                     }
                 }
-                drawables.mSelectedGrid.unbindArrays(gl);
+                GridDrawables.sSelectedGrid.unbindArrays(gl);
             }
-            drawables.mVideoGrid.bindArrays(gl);
+            GridDrawables.sVideoGrid.bindArrays(gl);
             Texture videoTexture = drawables.mTextureVideo;
             for (int i = firstBufferedVisibleSlot; i <= lastBufferedVisibleSlot; ++i) {
                 DisplayItem displayItem = displayItems[(i - firstBufferedVisibleSlot) * GridLayer.MAX_ITEMS_PER_SLOT];
@@ -587,7 +589,7 @@ public final class GridDrawManager {
                     }
                 }
             }
-            drawables.mVideoGrid.unbindArrays(gl);
+            GridDrawables.sVideoGrid.unbindArrays(gl);
             gl.glDepthFunc(GL10.GL_LEQUAL);
         }
     }
@@ -656,7 +658,9 @@ public final class GridDrawManager {
         gl.glTranslatef(-translateXf, -translateYf, -translateZf);
         float theta = (pass == PASS_FOCUS_CONTENT) ? displayItem.mAnimatedImageTheta + displayItem.mAnimatedTheta
                 : displayItem.mAnimatedTheta;
-        gl.glRotatef(theta, 0.0f, 0.0f, 1.0f);
+        if (theta != 0.0f) {
+            gl.glRotatef(theta, 0.0f, 0.0f, 1.0f);
+        }
         float orientation = 0.0f;
         if (pass == PASS_THUMBNAIL_CONTENT && displayItem.mAnimatedImageTheta != 0.0f) {
             orientation = displayItem.mAnimatedImageTheta;
@@ -666,7 +670,9 @@ public final class GridDrawManager {
         } else {
             GridQuad.draw(gl, orientation);
         }
-        gl.glRotatef(-theta, 0.0f, 0.0f, 1.0f);
+        if (theta != 0.0f) {
+            gl.glRotatef(-theta, 0.0f, 0.0f, 1.0f);
+        }
         gl.glTranslatef(translateXf, translateYf, translateZf);
         if (usingMixedTextures) {
             view.unbindMixed();

--- a/src/com/cooliris/media/GridDrawables.java
+++ b/src/com/cooliris/media/GridDrawables.java
@@ -3,19 +3,17 @@ package com.cooliris.media;
 import java.util.HashMap;
 
 import javax.microedition.khronos.opengles.GL11;
-import android.os.Process;
 
 public final class GridDrawables {
     // The display primitives.
-    public GridQuad mGrid;
-    public final GridQuadFrame mFrame;
-    public final GridQuad mTextGrid;
-    public final GridQuad mSelectedGrid;
-    public final GridQuad mVideoGrid;
-    public final GridQuad mLocationGrid;
-    public final GridQuad mSourceIconGrid;
-    public final GridQuad[] mFullscreenGrid = new GridQuad[3];
-    private GridQuad mGridNew;
+    public static GridQuad sGrid;
+    public static GridQuadFrame sFrame;
+    public static GridQuad sTextGrid;
+    public static GridQuad sSelectedGrid;
+    public static GridQuad sVideoGrid;
+    public static GridQuad sLocationGrid;
+    public static GridQuad sSourceIconGrid;
+    public static final GridQuad[] sFullscreenGrid = new GridQuad[3];
 
     // All the resource Textures.
     private static final int TEXTURE_FRAME = R.drawable.stack_frame;
@@ -31,7 +29,7 @@ public final class GridDrawables {
     public static final int[] TEXTURE_SPINNER = new int[8];
     private static final int TEXTURE_TRANSPARENT = R.drawable.transparent;
     private static final int TEXTURE_PLACEHOLDER = R.drawable.grid_placeholder;
-    
+
     public Texture mTextureFrame;
     public Texture mTextureGridFrame;
     public Texture mTextureFrameFocus;
@@ -47,9 +45,9 @@ public final class GridDrawables {
     public Texture mTexturePlaceholder;
 
     // The textures generated from strings.
-    public final HashMap<String, StringTexture> mStringTextureTable = new HashMap<String, StringTexture>(128);
+    public static final HashMap<String, StringTexture> sStringTextureTable = new HashMap<String, StringTexture>(128);
 
-    public GridDrawables(final int itemWidth, final int itemHeight) {
+    static {
         // We first populate the spinner textures.
         final int[] textureSpinner = TEXTURE_SPINNER;
         textureSpinner[0] = R.drawable.ic_spinner1;
@@ -60,107 +58,88 @@ public final class GridDrawables {
         textureSpinner[5] = R.drawable.ic_spinner6;
         textureSpinner[6] = R.drawable.ic_spinner7;
         textureSpinner[7] = R.drawable.ic_spinner8;
-        
-        final float height = 1.0f;
-        final float width = (float) (height * itemWidth) / (float) itemHeight;
-        final float aspectRatio = (float) itemWidth / (float) itemHeight;
-        final float oneByAspect = 1.0f / aspectRatio;
-
-        // We create the grid quad.
-        mGrid = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
-
-        // We create the quads used in fullscreen.
-        mFullscreenGrid[0] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
-        mFullscreenGrid[0].setDynamic(true);
-        mFullscreenGrid[1] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
-        mFullscreenGrid[1].setDynamic(true);
-        mFullscreenGrid[2] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
-        mFullscreenGrid[2].setDynamic(true);
-
-        // We create supplementary quads for the checkmarks, video overlay and location button
-        float sizeOfSelectedIcon = 32 * Gallery.PIXEL_DENSITY;  // In pixels.
-        sizeOfSelectedIcon /= itemHeight;
-        float sizeOfLocationIcon = 52 * Gallery.PIXEL_DENSITY;  // In pixels.
-        sizeOfLocationIcon /= itemHeight;
-        float sizeOfSourceIcon = 76 * Gallery.PIXEL_DENSITY;  // In pixels.
-        sizeOfSourceIcon /= itemHeight;
-        mSelectedGrid = GridQuad.createGridQuad(sizeOfSelectedIcon, sizeOfSelectedIcon, -0.5f, 0.25f, 1.0f, 1.0f, false);
-        mVideoGrid = GridQuad.createGridQuad(sizeOfSelectedIcon, sizeOfSelectedIcon, -0.08f, -0.09f, 1.0f, 1.0f, false);
-        mLocationGrid = GridQuad.createGridQuad(sizeOfLocationIcon, sizeOfLocationIcon, 0, 0, 1.0f, 1.0f, false);
-        mSourceIconGrid = GridQuad.createGridQuad(sizeOfSourceIcon, sizeOfSourceIcon, 0, 0, 1.0f, 1.0f, false);
-        
-        // We create the quad for the text label.
-        float seedTextWidth = (Gallery.PIXEL_DENSITY < 1.5f) ? 128.0f : 256.0f;
-        float textWidth = (seedTextWidth / (float) itemWidth) * width;
-        float textHeightPow2 = (Gallery.PIXEL_DENSITY < 1.5f) ? 32.0f : 64.0f;
-        float textHeight = (textHeightPow2 / (float) itemHeight) * height;
-        float textOffsetY = 0.0f;
-        mTextGrid = GridQuad.createGridQuad(textWidth, textHeight, 0, textOffsetY, 1.0f, 1.0f, false);
-
-        // We finally create the frame around every grid item
-        mFrame = GridQuadFrame.createFrame(width, height, itemWidth, itemHeight);
-        
-        Thread creationThread = new Thread() {
-            public void run() {
-                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
-                try {
-                    Thread.sleep(2000);
-                } catch (InterruptedException e) {
-                    ;
-                }
-                mGridNew = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, true);
-            }
-        };
-        creationThread.start();
     }
-    
-    public void swapGridQuads(GL11 gl) {
-        if (mGridNew != null) {
-            mGrid.freeHardwareBuffers(gl);
-            mGrid = mGridNew;
-            mGrid.generateHardwareBuffers(gl);
-            mGridNew = null;
+
+    public GridDrawables(final int itemWidth, final int itemHeight) {
+        if (sGrid == null) {
+            final float height = 1.0f;
+            final float width = (float) (height * itemWidth) / (float) itemHeight;
+            final float aspectRatio = (float) itemWidth / (float) itemHeight;
+            final float oneByAspect = 1.0f / aspectRatio;
+
+            // We create the grid quad.
+            sGrid = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, true);
+
+            // We create the quads used in fullscreen.
+            sFullscreenGrid[0] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
+            sFullscreenGrid[0].setDynamic(true);
+            sFullscreenGrid[1] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
+            sFullscreenGrid[1].setDynamic(true);
+            sFullscreenGrid[2] = GridQuad.createGridQuad(width, height, 0, 0, 1.0f, oneByAspect, false);
+            sFullscreenGrid[2].setDynamic(true);
+
+            // We create supplementary quads for the checkmarks, video overlay and location button
+            float sizeOfSelectedIcon = 32 * Gallery.PIXEL_DENSITY; // In pixels.
+            sizeOfSelectedIcon /= itemHeight;
+            float sizeOfLocationIcon = 52 * Gallery.PIXEL_DENSITY; // In pixels.
+            sizeOfLocationIcon /= itemHeight;
+            float sizeOfSourceIcon = 76 * Gallery.PIXEL_DENSITY; // In pixels.
+            sizeOfSourceIcon /= itemHeight;
+            sSelectedGrid = GridQuad.createGridQuad(sizeOfSelectedIcon, sizeOfSelectedIcon, -0.5f, 0.25f, 1.0f, 1.0f, false);
+            sVideoGrid = GridQuad.createGridQuad(sizeOfSelectedIcon, sizeOfSelectedIcon, -0.08f, -0.09f, 1.0f, 1.0f, false);
+            sLocationGrid = GridQuad.createGridQuad(sizeOfLocationIcon, sizeOfLocationIcon, 0, 0, 1.0f, 1.0f, false);
+            sSourceIconGrid = GridQuad.createGridQuad(sizeOfSourceIcon, sizeOfSourceIcon, 0, 0, 1.0f, 1.0f, false);
+
+            // We create the quad for the text label.
+            float seedTextWidth = (Gallery.PIXEL_DENSITY < 1.5f) ? 128.0f : 256.0f;
+            float textWidth = (seedTextWidth / (float) itemWidth) * width;
+            float textHeightPow2 = (Gallery.PIXEL_DENSITY < 1.5f) ? 32.0f : 64.0f;
+            float textHeight = (textHeightPow2 / (float) itemHeight) * height;
+            float textOffsetY = 0.0f;
+            sTextGrid = GridQuad.createGridQuad(textWidth, textHeight, 0, textOffsetY, 1.0f, 1.0f, false);
+
+            // We finally create the frame around every grid item
+            sFrame = GridQuadFrame.createFrame(width, height, itemWidth, itemHeight);
         }
     }
 
     public void onSurfaceCreated(RenderView view, GL11 gl) {
         // The grid quad.
-        mGrid.freeHardwareBuffers(gl);
-        mGrid.generateHardwareBuffers(gl);
+        sGrid.freeHardwareBuffers(gl);
+        sGrid.generateHardwareBuffers(gl);
 
         // The fullscreen quads.
-        mFullscreenGrid[0].freeHardwareBuffers(gl);
-        mFullscreenGrid[1].freeHardwareBuffers(gl);
-        mFullscreenGrid[2].freeHardwareBuffers(gl);
-        mFullscreenGrid[0].generateHardwareBuffers(gl);
-        mFullscreenGrid[1].generateHardwareBuffers(gl);
-        mFullscreenGrid[2].generateHardwareBuffers(gl);
+        sFullscreenGrid[0].freeHardwareBuffers(gl);
+        sFullscreenGrid[1].freeHardwareBuffers(gl);
+        sFullscreenGrid[2].freeHardwareBuffers(gl);
+        sFullscreenGrid[0].generateHardwareBuffers(gl);
+        sFullscreenGrid[1].generateHardwareBuffers(gl);
+        sFullscreenGrid[2].generateHardwareBuffers(gl);
 
         // Supplementary quads.
-        mSelectedGrid.freeHardwareBuffers(gl);
-        mVideoGrid.freeHardwareBuffers(gl);
-        mLocationGrid.freeHardwareBuffers(gl);
-        mSourceIconGrid.freeHardwareBuffers(gl);
-        mSelectedGrid.generateHardwareBuffers(gl);
-        mVideoGrid.generateHardwareBuffers(gl);
-        mLocationGrid.generateHardwareBuffers(gl);
-        mSourceIconGrid.generateHardwareBuffers(gl);
+        sSelectedGrid.freeHardwareBuffers(gl);
+        sVideoGrid.freeHardwareBuffers(gl);
+        sLocationGrid.freeHardwareBuffers(gl);
+        sSourceIconGrid.freeHardwareBuffers(gl);
+        sSelectedGrid.generateHardwareBuffers(gl);
+        sVideoGrid.generateHardwareBuffers(gl);
+        sLocationGrid.generateHardwareBuffers(gl);
+        sSourceIconGrid.generateHardwareBuffers(gl);
 
         // Text quads.
-        mTextGrid.freeHardwareBuffers(gl);
-        mTextGrid.generateHardwareBuffers(gl);
+        sTextGrid.freeHardwareBuffers(gl);
+        sTextGrid.generateHardwareBuffers(gl);
 
         // Frame mesh.
-        mFrame.freeHardwareBuffers(gl);
-        mFrame.generateHardwareBuffers(gl);
+        sFrame.freeHardwareBuffers(gl);
+        sFrame.generateHardwareBuffers(gl);
 
         // Clear the string table.
-        mStringTextureTable.clear();
-        
+        sStringTextureTable.clear();
+
         // Regenerate all the textures.
         mTextureFrame = view.getResource(TEXTURE_FRAME, false);
         mTextureGridFrame = view.getResource(TEXTURE_GRID_FRAME, false);
-        view.loadTexture(mTextureGridFrame);
         mTextureFrameFocus = view.getResource(TEXTURE_FRAME_FOCUS, false);
         mTextureFramePressed = view.getResource(TEXTURE_FRAME_PRESSED, false);
         mTextureLocation = view.getResource(TEXTURE_LOCATION, false);
@@ -171,7 +150,11 @@ public final class GridDrawables {
         mTexturePicasaSmall = view.getResource(TEXTURE_PICASA_SMALL, false);
         mTextureTransparent = view.getResource(TEXTURE_TRANSPARENT, false);
         mTexturePlaceholder = view.getResource(TEXTURE_PLACEHOLDER, false);
-        
+        view.loadTexture(mTextureFrame);
+        view.loadTexture(mTextureGridFrame);
+        view.loadTexture(mTextureFrameFocus);
+        view.loadTexture(mTextureFramePressed);
+
         mTextureSpinner[0] = view.getResource(R.drawable.ic_spinner1);
         mTextureSpinner[1] = view.getResource(R.drawable.ic_spinner2);
         mTextureSpinner[2] = view.getResource(R.drawable.ic_spinner3);

--- a/src/com/cooliris/media/GridInputProcessor.java
+++ b/src/com/cooliris/media/GridInputProcessor.java
@@ -438,14 +438,6 @@ public final class GridInputProcessor implements GestureDetector.OnGestureListen
         }
     }
 
-    public int getSelectedSlot() {
-        return mCurrentSelectedSlot;
-    }
-
-    public int getFocusSlot() {
-        return mCurrentFocusSlot;
-    }
-
     public void clearSelection() {
         mCurrentSelectedSlot = Shared.INVALID;
     }
@@ -489,10 +481,10 @@ public final class GridInputProcessor implements GestureDetector.OnGestureListen
                     slotsToSkip = maxSlots;
                 if (slotsToSkip < -maxSlots)
                     slotsToSkip = -maxSlots;
-                if (slotsToSkip <= 1) {
+                if (Math.abs(slotsToSkip) <= 1) {
                     if (velocityX > 0)
                         slotsToSkip = -2;
-                    else
+                    else if (velocityX < 0)
                         slotsToSkip = 2;
                 }
                 int slotToGetTo = mLayer.getAnchorSlotIndex(GridLayer.ANCHOR_CENTER) + slotsToSkip;

--- a/src/com/cooliris/media/GridLayer.java
+++ b/src/com/cooliris/media/GridLayer.java
@@ -21,24 +21,42 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     public static final int ANCHOR_RIGHT = 1;
     public static final int ANCHOR_CENTER = 2;
 
-    public static final int MAX_ITEMS_PER_SLOT = 24;
+    public static final int MAX_ITEMS_PER_SLOT = 12;
     public static final int MAX_DISPLAYED_ITEMS_PER_SLOT = 4;
     public static final int MAX_DISPLAY_SLOTS = 96;
     public static final int MAX_ITEMS_DRAWABLE = MAX_ITEMS_PER_SLOT * MAX_DISPLAY_SLOTS;
 
     private static final float SLIDESHOW_TRANSITION_TIME = 3.5f;
 
-    private HudLayer mHud;
+    private static HudLayer sHud;
     private int mState;
-    private IndexRange mBufferedVisibleRange;
-    private IndexRange mVisibleRange;
-    private IndexRange mPreviousDataRange;
-    private IndexRange mCompleteRange;
-    private Pool<Vector3f> mTempVec;
-    private final ArrayList<MediaItem> mTempList = new ArrayList<MediaItem>();
-    private final MediaItem[] mTempHash = new MediaItem[64];
-    private Vector3f mDeltaAnchorPositionUncommited;
-    private Vector3f mDeltaAnchorPosition;
+    private static final IndexRange sBufferedVisibleRange = new IndexRange();
+    private static final IndexRange sVisibleRange = new IndexRange();
+    private static final IndexRange sPreviousDataRange = new IndexRange();
+    private static final IndexRange sCompleteRange = new IndexRange();
+    
+    private static final Pool<Vector3f> sTempVec;
+    private static final Pool<Vector3f> sTempVecAlt;
+    static {
+        Vector3f[] vectorPool = new Vector3f[128];
+        int length = vectorPool.length;
+        for (int i = 0; i < length; ++i) {
+            vectorPool[i] = new Vector3f();
+        }
+        Vector3f[] vectorPoolRenderThread = new Vector3f[128];
+        length = vectorPoolRenderThread.length;
+        for (int i = 0; i < length; ++i) {
+            vectorPoolRenderThread[i] = new Vector3f();
+        }
+        sTempVec = new Pool<Vector3f>(vectorPool);
+        sTempVecAlt = new Pool<Vector3f>(vectorPoolRenderThread);
+    }
+    
+    private static final ArrayList<MediaItem> sTempList = new ArrayList<MediaItem>();
+    private static final MediaItem[] sTempHash = new MediaItem[64];
+    
+    private static final Vector3f sDeltaAnchorPositionUncommited = new Vector3f();
+    private static Vector3f sDeltaAnchorPosition = new Vector3f();
 
     // The display primitives.
     private GridDrawables mDrawables;
@@ -54,16 +72,18 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     private boolean mPerformingLayoutChange;
     private boolean mFeedChanged;
 
-    private LayoutInterface mLayoutInterface;
-    private LayoutInterface mPrevLayoutInterface;
+    private final LayoutInterface mLayoutInterface;
+    private static final LayoutInterface sfullScreenLayoutInterface = new GridLayoutInterface(1);
+    
     private MediaFeed mMediaFeed;
     private boolean mInAlbum = false;
     private int mCurrentExpandedSlot;
 
-    private ArrayList<MediaItem> mVisibleItems;
-    private DisplayList mDisplayList = new DisplayList();
-    private DisplayItem[] mDisplayItems = new DisplayItem[MAX_ITEMS_DRAWABLE];
-    private DisplaySlot[] mDisplaySlots = new DisplaySlot[MAX_DISPLAY_SLOTS];
+    private static final DisplayList sDisplayList = new DisplayList();
+    private static final DisplayItem[] sDisplayItems = new DisplayItem[MAX_ITEMS_DRAWABLE];
+    private static final DisplaySlot[] sDisplaySlots = new DisplaySlot[MAX_DISPLAY_SLOTS];
+    private static ArrayList<MediaItem> sVisibleItems;
+    
     private float mTimeElapsedSinceTransition;
     private BackgroundLayer mBackground;
     private boolean mLocationFilter;
@@ -75,9 +95,9 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     private boolean mSlideshowMode;
     private boolean mNoDeleteMode = false;
     private float mTimeElapsedSinceView;
-    private MediaBucketList mBucketList = new MediaBucketList();
+    private static final MediaBucketList sBucketList = new MediaBucketList();
     private float mTimeElapsedSinceStackViewReady;
-    private Pool<Vector3f> mTempVecAlt;
+
     private Context mContext;
     private RenderView mView;
     private boolean mPickIntent;
@@ -91,19 +111,8 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mBackground = new BackgroundLayer(this);
         mContext = context;
         mView = view;
-        Vector3f[] vectorPool = new Vector3f[128];
-        int length = vectorPool.length;
-        for (int i = 0; i < length; ++i) {
-            vectorPool[i] = new Vector3f();
-        }
-        Vector3f[] vectorPoolRenderThread = new Vector3f[128];
-        length = vectorPoolRenderThread.length;
-        for (int i = 0; i < length; ++i) {
-            vectorPoolRenderThread[i] = new Vector3f();
-        }
-        mTempVec = new Pool<Vector3f>(vectorPool);
-        mTempVecAlt = new Pool<Vector3f>(vectorPoolRenderThread);
-        DisplaySlot[] displaySlots = mDisplaySlots;
+        
+        DisplaySlot[] displaySlots = sDisplaySlots;
         for (int i = 0; i < MAX_DISPLAY_SLOTS; ++i) {
             DisplaySlot slot = new DisplaySlot();
             displaySlots[i] = slot;
@@ -111,39 +120,43 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mLayoutInterface = layoutInterface;
         mCamera = new GridCamera(0, 0, itemWidth, itemHeight);
         mDrawables = new GridDrawables(itemWidth, itemHeight);
-        mBufferedVisibleRange = new IndexRange();
-        mVisibleRange = new IndexRange();
-        mCompleteRange = new IndexRange();
-        mPreviousDataRange = new IndexRange();
-        mPreviousDataRange.begin = Shared.INVALID;
-        mPreviousDataRange.end = Shared.INVALID;
-        mDeltaAnchorPosition = new Vector3f();
-        mDeltaAnchorPositionUncommited = new Vector3f();
-        mPrevLayoutInterface = new GridLayoutInterface(1);
-        mVisibleItems = new ArrayList<MediaItem>();
-        mHud = new HudLayer(context);
-        mHud.setGridLayer(this);
-        mHud.getTimeBar().setListener(this);
-        mHud.getPathBar().pushLabel(R.drawable.icon_home_small, context.getResources().getString(R.string.app_name),
+        sBufferedVisibleRange.set(Shared.INVALID, Shared.INVALID);
+        sVisibleRange.set(Shared.INVALID, Shared.INVALID);
+        sCompleteRange.set(Shared.INVALID, Shared.INVALID);
+        sPreviousDataRange.set(Shared.INVALID, Shared.INVALID);
+        sDeltaAnchorPosition.set(0, 0, 0);
+        sDeltaAnchorPositionUncommited.set(0, 0, 0);
+        sBucketList.clear();
+        
+        sVisibleItems = new ArrayList<MediaItem>();
+        if (sHud == null) {
+            sHud = new HudLayer(context);
+        }
+        sHud.setContext(context);
+        sHud.setGridLayer(this);
+        sHud.getPathBar().clear();
+        sHud.setGridLayer(this);
+        sHud.getTimeBar().setListener(this);
+        sHud.getPathBar().pushLabel(R.drawable.icon_home_small, context.getResources().getString(R.string.app_name),
                 new Runnable() {
                     public void run() {
-                        if (mHud.getAlpha() == 1.0f) {
+                        if (sHud.getAlpha() == 1.0f) {
                             if (!mFeedAboutToChange) {
                                 setState(STATE_MEDIA_SETS);
                             }
                         } else {
-                            mHud.setAlpha(1.0f);
+                            sHud.setAlpha(1.0f);
                         }
                     }
                 });
         mCameraManager = new GridCameraManager(mCamera);
-        mDrawManager = new GridDrawManager(context, mCamera, mDrawables, mDisplayList, mDisplayItems, mDisplaySlots);
-        mInputProcessor = new GridInputProcessor(context, mCamera, this, mView, mTempVec, mDisplayItems);
+        mDrawManager = new GridDrawManager(context, mCamera, mDrawables, sDisplayList, sDisplayItems, sDisplaySlots);
+        mInputProcessor = new GridInputProcessor(context, mCamera, this, mView, sTempVec, sDisplayItems);
         setState(STATE_MEDIA_SETS);
     }
 
     public HudLayer getHud() {
-        return mHud;
+        return sHud;
     }
 
     public void shutdown() {
@@ -153,16 +166,11 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mContext = null;
         mInputProcessor = null;
         mBackground = null;
-        mBucketList = null;
+        sBucketList.clear();
         mCameraManager = null;
         mDrawManager = null;
-        mHud.shutDown();
-        mHud = null;
+        sHud.shutDown();
         mView = null;
-
-        mDisplayItems = null;
-        mDisplayList = null;
-        mDisplaySlots = null;
     }
 
     public void stop() {
@@ -178,13 +186,13 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mBackground.generate(view, lists);
         lists.blendedList.add(this);
         lists.hitTestList.add(this);
-        mHud.generate(view, lists);
+        sHud.generate(view, lists);
     }
 
     @Override
     protected void onSizeChanged() {
-        mHud.setSize(mWidth, mHeight);
-        mHud.setAlpha(1.0f);
+        sHud.setSize(mWidth, mHeight);
+        sHud.setAlpha(1.0f);
         mBackground.setSize(mWidth, mHeight);
         mTimeElapsedSinceTransition = 0.0f;
         if (mView != null) {
@@ -202,7 +210,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             feedUnchanged = true;
         }
         GridLayoutInterface layoutInterface = (GridLayoutInterface) mLayoutInterface;
-        GridLayoutInterface oldLayout = (GridLayoutInterface) mPrevLayoutInterface;
+        GridLayoutInterface oldLayout = (GridLayoutInterface) sfullScreenLayoutInterface;
         oldLayout.mNumRows = layoutInterface.mNumRows;
         oldLayout.mSpacingX = layoutInterface.mSpacingX;
         oldLayout.mSpacingY = layoutInterface.mSpacingY;
@@ -233,24 +241,24 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
                 MediaSet set = feed.getCurrentSet();
                 int icon = mDrawables.getIconForSet(set, true);
                 if (set != null) {
-                    mHud.getPathBar().pushLabel(icon, set.mNoCountTitleString, new Runnable() {
+                    sHud.getPathBar().pushLabel(icon, set.mNoCountTitleString, new Runnable() {
                         public void run() {
                             if (mFeedAboutToChange) {
                                 return;
                             }
-                            if (mHud.getAlpha() == 1.0f) {
+                            if (sHud.getAlpha() == 1.0f) {
                                 disableLocationFiltering();
                                 mInputProcessor.clearSelection();
                                 setState(STATE_GRID_VIEW);
                             } else {
-                                mHud.setAlpha(1.0f);
+                                sHud.setAlpha(1.0f);
                             }
                         }
                     });
                 }
             }
             if (mState == STATE_FULL_SCREEN) {
-                mHud.getPathBar().popLabel();
+                sHud.getPathBar().popLabel();
             }
             break;
         case STATE_TIMELINE:
@@ -269,12 +277,12 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             layoutInterface.mSpacingX = (int) (40 * Gallery.PIXEL_DENSITY);
             layoutInterface.mSpacingY = (int) (40 * Gallery.PIXEL_DENSITY);
             if (mState != STATE_FULL_SCREEN) {
-                mHud.getPathBar().pushLabel(R.drawable.ic_fs_details, "", new Runnable() {
+                sHud.getPathBar().pushLabel(R.drawable.ic_fs_details, "", new Runnable() {
                     public void run() {
-                        if (mHud.getAlpha() == 1.0f) {
-                            mHud.swapFullscreenLabel();
+                        if (sHud.getAlpha() == 1.0f) {
+                            sHud.swapFullscreenLabel();
                         }
-                        mHud.setAlpha(1.0f);
+                        sHud.setAlpha(1.0f);
                     }
                 });
             }
@@ -293,15 +301,15 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             layoutInterface.mSpacingY = (int) (70 * Gallery.PIXEL_DENSITY * yStretch);
             if (mInAlbum) {
                 if (mState == STATE_FULL_SCREEN) {
-                    mHud.getPathBar().popLabel();
+                    sHud.getPathBar().popLabel();
                 }
-                mHud.getPathBar().popLabel();
+                sHud.getPathBar().popLabel();
                 mInAlbum = false;
             }
             break;
         }
         mState = state;
-        mHud.onGridStateChanged();
+        sHud.onGridStateChanged();
         if (performLayout && mFeedAboutToChange == false) {
             onLayout(Shared.INVALID, Shared.INVALID, oldLayout);
         }
@@ -314,9 +322,9 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     protected void enableLocationFiltering(String label) {
         if (mLocationFilter == false) {
             mLocationFilter = true;
-            mHud.getPathBar().pushLabel(R.drawable.icon_location_small, label, new Runnable() {
+            sHud.getPathBar().pushLabel(R.drawable.icon_location_small, label, new Runnable() {
                 public void run() {
-                    if (mHud.getAlpha() == 1.0f) {
+                    if (sHud.getAlpha() == 1.0f) {
                         if (mState == STATE_FULL_SCREEN) {
                             mInputProcessor.clearSelection();
                             setState(STATE_GRID_VIEW);
@@ -324,7 +332,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
                             disableLocationFiltering();
                         }
                     } else {
-                        mHud.setAlpha(1.0f);
+                        sHud.setAlpha(1.0f);
                     }
                 }
             });
@@ -335,7 +343,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         if (mLocationFilter) {
             mLocationFilter = false;
             mMediaFeed.removeFilter();
-            mHud.getPathBar().popLabel();
+            sHud.getPathBar().popLabel();
         }
     }
 
@@ -344,7 +352,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             return false;
         }
         int state = mState;
-        if (mInputProcessor.getSelectedSlot() == Shared.INVALID) {
+        if (mInputProcessor.getCurrentSelectedSlot() == Shared.INVALID) {
             if (mLocationFilter) {
                 disableLocationFiltering();
                 setState(STATE_TIMELINE);
@@ -376,7 +384,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             }
             mWakeLock = null;
         }
-        mHud.setAlpha(1.0f);
+        sHud.setAlpha(1.0f);
     }
 
     @Override
@@ -394,7 +402,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         MediaFeed feed = mMediaFeed;
         if (feed != null) {
             feed.shutdown();
-            mDisplayList.clear();
+            sDisplayList.clear();
             mBackground.clear();
         }
         mMediaFeed = new MediaFeed(mContext, dataSource, this);
@@ -402,33 +410,33 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     public IndexRange getVisibleRange() {
-        return mVisibleRange;
+        return sVisibleRange;
     }
 
     public IndexRange getBufferedVisibleRange() {
-        return mBufferedVisibleRange;
+        return sBufferedVisibleRange;
     }
 
     public IndexRange getCompleteRange() {
-        return mCompleteRange;
+        return sCompleteRange;
     }
 
     private int hitTest(Vector3f worldPos, int itemWidth, int itemHeight) {
         int retVal = Shared.INVALID;
         int firstSlotIndex = 0;
         int lastSlotIndex = 0;
-        IndexRange rangeToUse = mVisibleRange;
+        IndexRange rangeToUse = sVisibleRange;
         synchronized (rangeToUse) {
             firstSlotIndex = rangeToUse.begin;
             lastSlotIndex = rangeToUse.end;
         }
-        Pool<Vector3f> pool = mTempVec;
+        Pool<Vector3f> pool = sTempVec;
         float itemWidthBy2 = itemWidth * 0.5f;
         float itemHeightBy2 = itemHeight * 0.5f;
         Vector3f position = pool.create();
         Vector3f deltaAnchorPosition = pool.create();
         try {
-            deltaAnchorPosition.set(mDeltaAnchorPosition);
+            deltaAnchorPosition.set(sDeltaAnchorPosition);
             for (int i = firstSlotIndex; i <= lastSlotIndex; ++i) {
                 GridCameraManager.getSlotPositionForSlotIndex(i, mCamera, mLayoutInterface, deltaAnchorPosition, position);
                 if (FloatUtils.boundsContainsPoint(position.x - itemWidthBy2, position.x + itemWidthBy2,
@@ -450,12 +458,12 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         if (displayItem != null) {
             imageTheta = displayItem.getImageTheta();
         }
-        mCameraManager.centerCameraForSlot(mLayoutInterface, slotIndex, baseConvergence, mDeltaAnchorPositionUncommited,
+        mCameraManager.centerCameraForSlot(mLayoutInterface, slotIndex, baseConvergence, sDeltaAnchorPositionUncommited,
                 mInputProcessor.getCurrentSelectedSlot(), mZoomValue, imageTheta, mState);
     }
 
     boolean constrainCameraForSlot(int slotIndex) {
-        return mCameraManager.constrainCameraForSlot(mLayoutInterface, slotIndex, mDeltaAnchorPosition, mCurrentFocusItemWidth,
+        return mCameraManager.constrainCameraForSlot(mLayoutInterface, slotIndex, sDeltaAnchorPosition, mCurrentFocusItemWidth,
                 mCurrentFocusItemHeight);
     }
 
@@ -475,10 +483,17 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         } else {
             mTimeElapsedSinceTransition = 0;
         }
+        if (mMediaFeed != null && mMediaFeed.isSingleImageMode()) {
+            HudLayer hud = getHud();
+            hud.getPathBar().setHidden(true);
+            hud.getMenuBar().setHidden(true);
+            if (hud.getMode() != HudLayer.MODE_NORMAL)
+                hud.setMode(HudLayer.MODE_NORMAL);
+        }
         if (view.elapsedLoadingExpensiveTextures() > 150 || (mMediaFeed != null && mMediaFeed.getWaitingForMediaScanner())) {
-            mHud.getPathBar().setAnimatedIcons(GridDrawables.TEXTURE_SPINNER);
+            sHud.getPathBar().setAnimatedIcons(GridDrawables.TEXTURE_SPINNER);
         } else {
-            mHud.getPathBar().setAnimatedIcons(null);
+            sHud.getPathBar().setAnimatedIcons(null);
         }
 
         // In that case, we need to commit the respective Display Items when the
@@ -486,19 +501,19 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         GridCamera camera = mCamera;
         camera.update(timeElapsed);
         DisplayItem anchorDisplayItem = getAnchorDisplayItem(ANCHOR_CENTER);
-        if (anchorDisplayItem != null && !mHud.getTimeBar().isDragged()) {
-            mHud.getTimeBar().setItem(anchorDisplayItem.mItemRef);
+        if (anchorDisplayItem != null && !sHud.getTimeBar().isDragged()) {
+            sHud.getTimeBar().setItem(anchorDisplayItem.mItemRef);
         }
-        mDisplayList.update(timeElapsed);
+        sDisplayList.update(timeElapsed);
         mInputProcessor.update(timeElapsed);
         mSelectedAlpha = FloatUtils.animate(mSelectedAlpha, mTargetAlpha, timeElapsed * 0.5f);
         if (mState == STATE_FULL_SCREEN) {
-            mHud.autoHide(true);
+            sHud.autoHide(true);
         } else {
-            mHud.autoHide(false);
-            mHud.setAlpha(1.0f);
+            sHud.autoHide(false);
+            sHud.setAlpha(1.0f);
         }
-        GridQuad[] fullscreenQuads = mDrawables.mFullscreenGrid;
+        GridQuad[] fullscreenQuads = GridDrawables.sFullscreenGrid;
         int numFullScreenQuads = fullscreenQuads.length;
         for (int i = 0; i < numFullScreenQuads; ++i) {
             fullscreenQuads[i].update(timeElapsed);
@@ -531,7 +546,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         } catch (InterruptedException e) {
 
         }
-        if (mDisplayList.getNumAnimatables() != 0 || mCamera.isAnimating()
+        if (sDisplayList.getNumAnimatables() != 0 || mCamera.isAnimating()
                 || (mTimeElapsedSinceTransition > 0.0f && mTimeElapsedSinceTransition < 1.0f) || mSelectedAlpha != mTargetAlpha
                 // || (mAnimatedFov != mTargetFov)
                 || dirty)
@@ -543,41 +558,40 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     private void computeVisibleRange() {
         if (mPerformingLayoutChange)
             return;
-        if (mDeltaAnchorPosition.equals(mDeltaAnchorPositionUncommited) == false) {
-            mDeltaAnchorPosition.set(mDeltaAnchorPositionUncommited);
+        if (sDeltaAnchorPosition.equals(sDeltaAnchorPositionUncommited) == false) {
+            sDeltaAnchorPosition.set(sDeltaAnchorPositionUncommited);
         }
-        mCameraManager.computeVisibleRange(mMediaFeed, mLayoutInterface, mDeltaAnchorPosition, mVisibleRange,
-                mBufferedVisibleRange, mCompleteRange, mState);
+        mCameraManager.computeVisibleRange(mMediaFeed, mLayoutInterface, sDeltaAnchorPosition, sVisibleRange,
+                sBufferedVisibleRange, sCompleteRange, mState);
     }
 
     private void computeVisibleItems() {
         if (mFeedAboutToChange == true || mPerformingLayoutChange == true) {
             return;
         }
-
         computeVisibleRange();
-        int deltaBegin = mBufferedVisibleRange.begin - mPreviousDataRange.begin;
-        int deltaEnd = mBufferedVisibleRange.end - mPreviousDataRange.end;
+        int deltaBegin = sBufferedVisibleRange.begin - sPreviousDataRange.begin;
+        int deltaEnd = sBufferedVisibleRange.end - sPreviousDataRange.end;
         if (deltaBegin != 0 || deltaEnd != 0) {
             // The delta has changed, we have to compute the display items again.
             // We find the intersection range, these slots have not changed at all.
-            int firstVisibleSlotIndex = mBufferedVisibleRange.begin;
-            int lastVisibleSlotIndex = mBufferedVisibleRange.end;
-            mPreviousDataRange.begin = firstVisibleSlotIndex;
-            mPreviousDataRange.end = lastVisibleSlotIndex;
+            int firstVisibleSlotIndex = sBufferedVisibleRange.begin;
+            int lastVisibleSlotIndex = sBufferedVisibleRange.end;
+            sPreviousDataRange.begin = firstVisibleSlotIndex;
+            sPreviousDataRange.end = lastVisibleSlotIndex;
 
-            Pool<Vector3f> pool = mTempVec;
+            Pool<Vector3f> pool = sTempVec;
             Vector3f position = pool.create();
             Vector3f deltaAnchorPosition = pool.create();
             try {
                 MediaFeed feed = mMediaFeed;
-                DisplayList displayList = mDisplayList;
-                DisplayItem[] displayItems = mDisplayItems;
-                DisplaySlot[] displaySlots = mDisplaySlots;
+                DisplayList displayList = sDisplayList;
+                DisplayItem[] displayItems = sDisplayItems;
+                DisplaySlot[] displaySlots = sDisplaySlots;
                 int numDisplayItems = displayItems.length;
                 int numDisplaySlots = displaySlots.length;
-                ArrayList<MediaItem> visibleItems = mVisibleItems;
-                deltaAnchorPosition.set(mDeltaAnchorPosition);
+                ArrayList<MediaItem> visibleItems = sVisibleItems;
+                deltaAnchorPosition.set(sDeltaAnchorPosition);
                 LayoutInterface layout = mLayoutInterface;
                 GridCamera camera = mCamera;
                 for (int i = firstVisibleSlotIndex; i <= lastVisibleSlotIndex; ++i) {
@@ -588,12 +602,15 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
                     if (set != null && indexIntoSlots >= 0 && indexIntoSlots < numDisplaySlots) {
                         ArrayList<MediaItem> items = set.getItems();
                         displaySlots[indexIntoSlots].setMediaSet(set);
-                        ArrayList<MediaItem> bestItems = mTempList;
+                        ArrayList<MediaItem> bestItems = sTempList;
                         if (mTimeElapsedSinceTransition < 1.0f) {
-                            ArrayUtils.computeSortedIntersection(visibleItems, items, MAX_ITEMS_PER_SLOT, bestItems, mTempHash);
+                            // We always show the same top thumbnails for a stack of albums
+                            if (mState == STATE_MEDIA_SETS)
+                                ArrayUtils.computeSortedIntersection(items, visibleItems, MAX_ITEMS_PER_SLOT, bestItems, sTempHash);
+                            else
+                                ArrayUtils.computeSortedIntersection(visibleItems, items, MAX_ITEMS_PER_SLOT, bestItems, sTempHash);
                         }
-
-                        // TODO: Could be problematic with dummy items in set.
+                        
                         int numItemsInSet = set.getNumItems();
                         int numBestItems = bestItems.size();
                         int originallyFoundItems = numBestItems;
@@ -621,7 +638,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
                                 MediaItem item = bestItems.get(j);
                                 if (item != null) {
                                     DisplayItem displayItem = displayList.get(item);
-                                    if (mState == STATE_FULL_SCREEN
+                                    if ((mState == STATE_FULL_SCREEN && i != mInputProcessor.getCurrentSelectedSlot())
                                             || (mState == STATE_GRID_VIEW && (mTimeElapsedSinceTransition > 1.0f || j >= originallyFoundItems))) {
                                         displayItem.set(position, j, false);
                                         displayItem.commit();
@@ -642,22 +659,22 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
                     mFeedChanged = false;
                     if (mInputProcessor != null && mState == STATE_FULL_SCREEN) {
                         int currentSelectedSlot = mInputProcessor.getCurrentSelectedSlot();
-                        if (currentSelectedSlot > mCompleteRange.end)
-                            currentSelectedSlot = mCompleteRange.end;
+                        if (currentSelectedSlot > sCompleteRange.end)
+                            currentSelectedSlot = sCompleteRange.end;
                         mInputProcessor.setCurrentSelectedSlot(currentSelectedSlot);
                     }
                     if (mState == STATE_GRID_VIEW) {
                         MediaSet expandedSet = mMediaFeed.getExpandedMediaSet();
                         if (expandedSet != null) {
-                            if (!mHud.getPathBar().getCurrentLabel().equals(expandedSet.mNoCountTitleString)) {
-                                mHud.getPathBar().changeLabel(expandedSet.mNoCountTitleString);
+                            if (!sHud.getPathBar().getCurrentLabel().equals(expandedSet.mNoCountTitleString)) {
+                                sHud.getPathBar().changeLabel(expandedSet.mNoCountTitleString);
                             }
                         }
                     }
                     if (mRequestFocusContentUri != null) {
                         // We have to find the item that has this contentUri
                         if (mState == STATE_FULL_SCREEN) {
-                            int numSlots = mCompleteRange.end;
+                            int numSlots = sCompleteRange.end;
                             for (int i = 0; i < numSlots; ++i) {
                                 MediaSet set = feed.getSetForSlot(i);
                                 ArrayList<MediaItem> items = set.getItems();
@@ -679,7 +696,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             }
             // We keep upto 400 thumbnails in memory.
             int numThumbnailsToKeepInMemory = (mState == STATE_MEDIA_SETS || mState == STATE_TIMELINE) ? 100 : 400;
-            int startMemoryRange = (mBufferedVisibleRange.begin / numThumbnailsToKeepInMemory) * numThumbnailsToKeepInMemory;
+            int startMemoryRange = (sBufferedVisibleRange.begin / numThumbnailsToKeepInMemory) * numThumbnailsToKeepInMemory;
             if (mStartMemoryRange != startMemoryRange) {
                 mStartMemoryRange = startMemoryRange;
                 clearUnusedThumbnails();
@@ -690,22 +707,23 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     @Override
     public void handleLowMemory() {
         clearUnusedThumbnails();
-        mDrawables.mStringTextureTable.clear();
+        GridDrawables.sStringTextureTable.clear();
         mBackground.clearCache();
     }
 
     // This method can be potentially expensive
     public void clearUnusedThumbnails() {
-        mDisplayList.clearExcept(mDisplayItems);
+        sDisplayList.clearExcept(sDisplayItems);
     }
 
     @Override
     public void onSurfaceCreated(RenderView view, GL11 gl) {
-        mDisplayList.clear();
-        mHud.clear();
-        mHud.reset();
-        mDrawables.mStringTextureTable.clear();
+        sDisplayList.clear();
+        sHud.clear();
+        sHud.reset();
+        GridDrawables.sStringTextureTable.clear();
         mDrawables.onSurfaceCreated(view, gl);
+        mBackground.clear();
     }
 
     @Override
@@ -720,7 +738,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         GridCamera camera = mCamera;
         int selectedSlotIndex = mInputProcessor.getCurrentSelectedSlot();
         computeVisibleItems();
-
+        
         gl.glMatrixMode(GL11.GL_MODELVIEW);
         gl.glLoadIdentity();
         GLU.gluLookAt(gl, -camera.mEyeX, -camera.mEyeY, -camera.mEyeZ, -camera.mLookAtX, -camera.mLookAtY, -camera.mLookAtZ,
@@ -736,12 +754,14 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         } else {
             mTargetAlpha = 1.0f;
         }
-        mDrawManager.prepareDraw(mBufferedVisibleRange, mVisibleRange, selectedSlotIndex, mInputProcessor.getCurrentFocusSlot(),
+        mDrawManager.prepareDraw(sBufferedVisibleRange, sVisibleRange, selectedSlotIndex, mInputProcessor.getCurrentFocusSlot(),
                 mInputProcessor.isFocusItemPressed());
         if (mSelectedAlpha != 0.0f) {
             mDrawManager.drawThumbnails(view, gl, mState);
         }
-        gl.glDisable(GL11.GL_BLEND);
+        if (mSelectedAlpha != 1.0f) {
+            gl.glDisable(GL11.GL_BLEND);
+        }
         // We draw the selected slotIndex.
         if (selectedSlotIndex != Shared.INVALID) {
             mDrawManager.drawFocusItems(view, gl, mZoomValue, mSlideshowMode, mTimeElapsedSinceView);
@@ -753,15 +773,15 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
 
     public void renderBlended(RenderView view, GL11 gl) {
         // We draw the placeholder for all visible slots.
-        if (mHud != null && mDrawManager != null) {
-            mDrawManager.drawBlendedComponents(view, gl, mSelectedAlpha, mState, mHud.getMode(), mTimeElapsedSinceStackViewReady,
-                    mTimeElapsedSinceGridViewReady, mBucketList, mMediaFeed.getWaitingForMediaScanner() || mFeedAboutToChange
+        if (sHud != null && mDrawManager != null) {
+            mDrawManager.drawBlendedComponents(view, gl, mSelectedAlpha, mState, sHud.getMode(), mTimeElapsedSinceStackViewReady,
+                    mTimeElapsedSinceGridViewReady, sBucketList, mMediaFeed.getWaitingForMediaScanner() || mFeedAboutToChange
                             || mMediaFeed.isLoading());
         }
     }
 
     public synchronized void onLayout(int newAnchorSlotIndex, int currentAnchorSlotIndex, LayoutInterface oldLayout) {
-        if (mPerformingLayoutChange || !mDeltaAnchorPosition.equals(mDeltaAnchorPositionUncommited)) {
+        if (mPerformingLayoutChange || !sDeltaAnchorPosition.equals(sDeltaAnchorPositionUncommited)) {
             return;
         }
 
@@ -769,7 +789,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mPerformingLayoutChange = true;
         LayoutInterface layout = mLayoutInterface;
         if (oldLayout == null) {
-            oldLayout = mPrevLayoutInterface;
+            oldLayout = sfullScreenLayoutInterface;
         }
         GridCamera camera = mCamera;
         if (currentAnchorSlotIndex == Shared.INVALID) {
@@ -787,7 +807,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         }
         int itemHeight = camera.mItemHeight;
         int itemWidth = camera.mItemWidth;
-        Pool<Vector3f> pool = mTempVec;
+        Pool<Vector3f> pool = sTempVec;
         Vector3f deltaAnchorPosition = pool.create();
         Vector3f currentSlotPosition = pool.create();
         try {
@@ -795,12 +815,12 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             if (currentAnchorSlotIndex != Shared.INVALID && newAnchorSlotIndex != Shared.INVALID) {
                 layout.getPositionForSlotIndex(newAnchorSlotIndex, itemWidth, itemHeight, deltaAnchorPosition);
                 oldLayout.getPositionForSlotIndex(currentAnchorSlotIndex, itemWidth, itemHeight, currentSlotPosition);
-                currentSlotPosition.subtract(mDeltaAnchorPosition);
+                currentSlotPosition.subtract(sDeltaAnchorPosition);
                 deltaAnchorPosition.subtract(currentSlotPosition);
                 deltaAnchorPosition.y = 0;
                 deltaAnchorPosition.z = 0;
             }
-            mDeltaAnchorPositionUncommited.set(deltaAnchorPosition);
+            sDeltaAnchorPositionUncommited.set(deltaAnchorPosition);
         } finally {
             pool.delete(deltaAnchorPosition);
             pool.delete(currentSlotPosition);
@@ -817,8 +837,8 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     private void forceRecomputeVisibleRange() {
-        mPreviousDataRange.begin = Shared.INVALID;
-        mPreviousDataRange.end = Shared.INVALID;
+        sPreviousDataRange.begin = Shared.INVALID;
+        sPreviousDataRange.end = Shared.INVALID;
         if (mView != null) {
             mView.requestRender();
         }
@@ -830,7 +850,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             mFeedChanged = true;
             forceRecomputeVisibleRange();
             if (mState == STATE_GRID_VIEW || mState == STATE_FULL_SCREEN)
-                mHud.setFeed(feed, mState, needsLayout);
+                sHud.setFeed(feed, mState, needsLayout);
             return;
         }
 
@@ -838,21 +858,21 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             Thread.yield();
         }
         if (mState == STATE_GRID_VIEW) {
-            if (mHud != null) {
+            if (sHud != null) {
                 MediaSet set = feed.getCurrentSet();
                 if (set != null && !mLocationFilter)
-                    mHud.getPathBar().changeLabel(set.mNoCountTitleString);
+                    sHud.getPathBar().changeLabel(set.mNoCountTitleString);
             }
         }
-        DisplayItem[] displayItems = mDisplayItems;
-        int firstBufferedVisibleSlotIndex = mBufferedVisibleRange.begin;
-        int lastBufferedVisibleSlotIndex = mBufferedVisibleRange.end;
+        DisplayItem[] displayItems = sDisplayItems;
+        int firstBufferedVisibleSlotIndex = sBufferedVisibleRange.begin;
+        int lastBufferedVisibleSlotIndex = sBufferedVisibleRange.end;
         int currentlyVisibleSlotIndex = getAnchorSlotIndex(ANCHOR_CENTER);
         if (mCurrentExpandedSlot != Shared.INVALID) {
             currentlyVisibleSlotIndex = mCurrentExpandedSlot;
         }
         MediaItem anchorItem = null;
-        ArrayList<MediaItem> visibleItems = mVisibleItems;
+        ArrayList<MediaItem> visibleItems = sVisibleItems;
         visibleItems.clear();
         visibleItems.ensureCapacity(lastBufferedVisibleSlotIndex - firstBufferedVisibleSlotIndex);
         if (currentlyVisibleSlotIndex != Shared.INVALID && currentlyVisibleSlotIndex >= firstBufferedVisibleSlotIndex
@@ -915,7 +935,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         // We must create a new display store now since the data has changed.
         if (newSlotIndex != Shared.INVALID) {
             if (mState == STATE_MEDIA_SETS) {
-                mDisplayList.clearExcept(displayItems);
+                sDisplayList.clearExcept(displayItems);
             }
             onLayout(newSlotIndex, currentlyVisibleSlotIndex, null);
         } else {
@@ -925,25 +945,37 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mFeedAboutToChange = false;
         mFeedChanged = true;
         if (feed != null) {
-            mHud.setFeed(feed, mState, needsLayout);
+            if (mState == STATE_GRID_VIEW || mState == STATE_FULL_SCREEN)
+                sHud.setFeed(feed, mState, needsLayout);
         }
         if (mView != null) {
             mView.requestRender();
         }
     }
+    
+    public DisplayItem getRepresentativeDisplayItem() {
+        int slotIndex = Shared.INVALID;
+        if (mInputProcessor != null) {
+            slotIndex = mInputProcessor.getCurrentFocusSlot();
+        }
+        if (slotIndex == Shared.INVALID) {
+            slotIndex = getAnchorSlotIndex(ANCHOR_CENTER);
+        }
+        return sDisplayItems[(slotIndex - sBufferedVisibleRange.begin) * MAX_ITEMS_PER_SLOT];
+    }
 
     public DisplayItem getAnchorDisplayItem(int type) {
         int slotIndex = getAnchorSlotIndex(type);
-        return mDisplayItems[(slotIndex - mBufferedVisibleRange.begin) * MAX_ITEMS_PER_SLOT];
+        return sDisplayItems[(slotIndex - sBufferedVisibleRange.begin) * MAX_ITEMS_PER_SLOT];
     }
 
     public float getScrollPosition() {
-        return (mCamera.mLookAtX * mCamera.mScale + mDeltaAnchorPosition.x); // in
+        return (mCamera.mLookAtX * mCamera.mScale + sDeltaAnchorPosition.x); // in
         // pixels
     }
 
     public DisplayItem getDisplayItemForScrollPosition(float posX) {
-        Pool<Vector3f> pool = mTempVecAlt;
+        Pool<Vector3f> pool = sTempVecAlt;
         MediaFeed feed = mMediaFeed;
         int itemWidth = mCamera.mItemWidth;
         int itemHeight = mCamera.mItemHeight;
@@ -978,7 +1010,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         if (set != null) {
             ArrayList<MediaItem> items = set.getItems();
             if (items != null && set.getNumItems() > 0) {
-                return (mDisplayList.get(items.get(0)));
+                return (sDisplayList.get(items.get(0)));
             }
         }
         return null;
@@ -989,22 +1021,22 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         int retVal = 0;
         switch (anchorType) {
         case ANCHOR_LEFT:
-            retVal = mVisibleRange.begin;
+            retVal = sVisibleRange.begin;
             break;
         case ANCHOR_RIGHT:
-            retVal = mVisibleRange.end;
+            retVal = sVisibleRange.end;
             break;
         case ANCHOR_CENTER:
-            retVal = (mVisibleRange.begin + mVisibleRange.end) / 2;
+            retVal = (sVisibleRange.begin + sVisibleRange.end) / 2;
             break;
         }
         return retVal;
     }
 
     DisplayItem getDisplayItemForSlotId(int slotId) {
-        int index = slotId - mBufferedVisibleRange.begin;
-        if (index >= 0 && slotId <= mBufferedVisibleRange.end) {
-            return mDisplayItems[index * MAX_ITEMS_PER_SLOT];
+        int index = slotId - sBufferedVisibleRange.begin;
+        if (index >= 0 && slotId <= sBufferedVisibleRange.end) {
+            return sDisplayItems[index * MAX_ITEMS_PER_SLOT];
         }
         return null;
     }
@@ -1014,20 +1046,20 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         boolean retVal = changeFocusToSlot(currentSelectedSlot + 1, convergence);
         if (mInputProcessor.getCurrentSelectedSlot() == currentSelectedSlot) {
             endSlideshow();
-            mHud.setAlpha(1.0f);
+            sHud.setAlpha(1.0f);
         }
         return retVal;
     }
 
     boolean changeFocusToSlot(int slotId, float convergence) {
         mZoomValue = 1.0f;
-        int index = slotId - mBufferedVisibleRange.begin;
-        if (index >= 0 && slotId <= mBufferedVisibleRange.end) {
-            DisplayItem displayItem = mDisplayItems[index * MAX_ITEMS_PER_SLOT];
+        int index = slotId - sBufferedVisibleRange.begin;
+        if (index >= 0 && slotId <= sBufferedVisibleRange.end) {
+            DisplayItem displayItem = sDisplayItems[index * MAX_ITEMS_PER_SLOT];
             if (displayItem != null) {
                 MediaItem item = displayItem.mItemRef;
-                mHud.fullscreenSelectionChanged(item, slotId + 1, mCompleteRange.end + 1);
-                if (slotId != Shared.INVALID && slotId <= mCompleteRange.end) {
+                sHud.fullscreenSelectionChanged(item, slotId + 1, sCompleteRange.end + 1);
+                if (slotId != Shared.INVALID && slotId <= sCompleteRange.end) {
                     mInputProcessor.setCurrentFocusSlot(slotId);
                     centerCameraForSlot(slotId, convergence);
                     return true;
@@ -1045,12 +1077,12 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     public ArrayList<MediaBucket> getSelectedBuckets() {
-        return mBucketList.get();
+        return sBucketList.get();
     }
 
     public void selectAll() {
         if (mState != STATE_FULL_SCREEN) {
-            int numSlots = mCompleteRange.end + 1;
+            int numSlots = sCompleteRange.end + 1;
             for (int i = 0; i < numSlots; ++i) {
                 addSlotToSelectedItems(i, false, false);
             }
@@ -1061,17 +1093,17 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     public void deselectOrCancelSelectMode() {
-        if (mBucketList.size() == 0) {
-            mHud.cancelSelection();
+        if (sBucketList.size() == 0) {
+            sHud.cancelSelection();
         } else {
-            mBucketList.clear();
+            sBucketList.clear();
             updateCountOfSelectedItems();
         }
     }
 
     public void deselectAll() {
-        mHud.cancelSelection();
-        mBucketList.clear();
+        sHud.cancelSelection();
+        sBucketList.clear();
         updateCountOfSelectedItems();
     }
 
@@ -1081,7 +1113,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         deselectAll();
 
         // If the current set is now empty, return to the parent set.
-        if (mCompleteRange.isEmpty()) {
+        if (sCompleteRange.isEmpty()) {
             goBack(); // TODO(venkat): This does not work most of the time, can you take a look?
         }
     }
@@ -1089,17 +1121,17 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     void addSlotToSelectedItems(int slotId, boolean removeIfAlreadyAdded, boolean updateCount) {
         if (mFeedAboutToChange == false) {
             MediaFeed feed = mMediaFeed;
-            mBucketList.add(slotId, feed, removeIfAlreadyAdded);
+            sBucketList.add(slotId, feed, removeIfAlreadyAdded);
             if (updateCount) {
                 updateCountOfSelectedItems();
-                if (mBucketList.size() == 0)
+                if (sBucketList.size() == 0)
                     deselectAll();
             }
         }
     }
 
     private void updateCountOfSelectedItems() {
-        mHud.updateNumItemsSelected(mBucketList.size());
+        sHud.updateNumItemsSelected(sBucketList.size());
     }
 
     public int getMetadataSlotIndexForScreenPosition(int posX, int posY) {
@@ -1112,7 +1144,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     private int getSlotForScreenPosition(int posX, int posY, int itemWidth, int itemHeight) {
-        Pool<Vector3f> pool = mTempVec;
+        Pool<Vector3f> pool = sTempVec;
         int retVal = 0;
         Vector3f worldPos = pool.create();
         try {
@@ -1148,7 +1180,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             mCurrentExpandedSlot = slotIndex;
             goBack();
             if (metadata) {
-                DisplaySlot slot = mDisplaySlots[slotIndex - mBufferedVisibleRange.begin];
+                DisplaySlot slot = sDisplaySlots[slotIndex - sBufferedVisibleRange.begin];
                 if (slot.hasValidLocation()) {
                     MediaSet set = slot.getMediaSet();
                     if (set.mReverseGeocodedLocation != null) {
@@ -1196,7 +1228,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         mZoomValue = 1.0f;
         centerCameraForSlot(mInputProcessor.getCurrentSelectedSlot(), 1.0f);
         mTimeElapsedSinceView = SLIDESHOW_TRANSITION_TIME - 1.0f;
-        mHud.setAlpha(0);
+        sHud.setAlpha(0);
         PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
         mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "GridView.Slideshow");
         mWakeLock.acquire();
@@ -1204,7 +1236,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
 
     public void enterSelectionMode() {
         mSlideshowMode = false;
-        mHud.enterSelectionMode();
+        sHud.enterSelectionMode();
         int currentSlot = mInputProcessor.getCurrentSelectedSlot();
         if (currentSlot == Shared.INVALID) {
             currentSlot = mInputProcessor.getCurrentFocusSlot();
@@ -1213,7 +1245,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     private float getFillScreenZoomValue() {
-        return GridCameraManager.getFillScreenZoomValue(mCamera, mTempVec, mCurrentFocusItemWidth, mCurrentFocusItemHeight);
+        return GridCameraManager.getFillScreenZoomValue(mCamera, sTempVec, mCurrentFocusItemWidth, mCurrentFocusItemHeight);
     }
 
     public void zoomInToSelectedItem() {
@@ -1227,7 +1259,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         if (mZoomValue > 6.0f) {
             mZoomValue = 6.0f;
         }
-        mHud.setAlpha(1.0f);
+        sHud.setAlpha(1.0f);
         centerCameraForSlot(mInputProcessor.getCurrentSelectedSlot(), 1.0f);
     }
 
@@ -1241,14 +1273,14 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
         if (mZoomValue < 1.0f) {
             mZoomValue = 1.0f;
         }
-        mHud.setAlpha(1.0f);
+        sHud.setAlpha(1.0f);
         centerCameraForSlot(mInputProcessor.getCurrentSelectedSlot(), 1.0f);
     }
 
     public void rotateSelectedItems(float f) {
-        MediaBucketList bucketList = mBucketList;
+        MediaBucketList bucketList = sBucketList;
         ArrayList<MediaBucket> mediaBuckets = bucketList.get();
-        DisplayList displayList = mDisplayList;
+        DisplayList displayList = sDisplayList;
         int numBuckets = mediaBuckets.size();
         for (int i = 0; i < numBuckets; ++i) {
             MediaBucket bucket = mediaBuckets.get(i);
@@ -1307,7 +1339,7 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
     }
 
     public Vector3f getDeltaAnchorPosition() {
-        return mDeltaAnchorPosition;
+        return sDeltaAnchorPosition;
     }
 
     public int getExpandedSlot() {
@@ -1325,16 +1357,16 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
 
     public void setPickIntent(boolean b) {
         mPickIntent = b;
-        mHud.getPathBar().popLabel();
-        mHud.getPathBar().pushLabel(R.drawable.icon_location_small, mContext.getResources().getString(R.string.pick),
+        sHud.getPathBar().popLabel();
+        sHud.getPathBar().pushLabel(R.drawable.icon_location_small, mContext.getResources().getString(R.string.pick),
                 new Runnable() {
                     public void run() {
-                        if (mHud.getAlpha() == 1.0f) {
+                        if (sHud.getAlpha() == 1.0f) {
                             if (!mFeedAboutToChange) {
                                 setState(STATE_MEDIA_SETS);
                             }
                         } else {
-                            mHud.setAlpha(1.0f);
+                            sHud.setAlpha(1.0f);
                         }
                     }
                 });
@@ -1350,18 +1382,18 @@ public final class GridLayer extends RootLayer implements MediaFeed.Listener, Ti
             mMediaFeed.expandMediaSet(0);
             setState(STATE_GRID_VIEW);
             // We need to make sure we haven't pushed the same label twice
-            if (mHud.getPathBar().getNumLevels() == 1) {
-                mHud.getPathBar().pushLabel(R.drawable.icon_folder_small, setName, new Runnable() {
+            if (sHud.getPathBar().getNumLevels() == 1) {
+                sHud.getPathBar().pushLabel(R.drawable.icon_folder_small, setName, new Runnable() {
                     public void run() {
                         if (mFeedAboutToChange) {
                             return;
                         }
-                        if (mHud.getAlpha() == 1.0f) {
+                        if (sHud.getAlpha() == 1.0f) {
                         disableLocationFiltering();
                         mInputProcessor.clearSelection();
                         setState(STATE_GRID_VIEW);
                         } else {
-                            mHud.setAlpha(1.0f);
+                            sHud.setAlpha(1.0f);
                         }
                     }
                 });

--- a/src/com/cooliris/media/HudLayer.java
+++ b/src/com/cooliris/media/HudLayer.java
@@ -15,6 +15,7 @@ import android.content.pm.ResolveInfo;
 import android.content.res.Resources;
 import android.net.Uri;
 import android.util.FloatMath;
+import android.util.Log;
 import android.view.MotionEvent;
 
 import com.cooliris.media.MenuBar.Menu;
@@ -24,13 +25,13 @@ public final class HudLayer extends Layer {
     public static final int MODE_NORMAL = 0;
     public static final int MODE_SELECT = 1;
 
-    private final Context mContext;
+    private Context mContext;
     private GridLayer mGridLayer;
     private final ImageButton mTopRightButton = new ImageButton();
     private final ImageButton mZoomInButton = new ImageButton();
     private final ImageButton mZoomOutButton = new ImageButton();
-    private final PathBarLayer mPathBar;
-    private final TimeBar mTimeBar;
+    private static PathBarLayer sPathBar;
+    private static TimeBar sTimeBar;
     private MenuBar.Menu[] mNormalBottomMenu = null;
     private MenuBar.Menu[] mSingleViewIntentBottomMenu = null;
     private final MenuBar mSelectionMenuBottom;
@@ -103,9 +104,10 @@ public final class HudLayer extends Layer {
 
     HudLayer(Context context) {
         mAlpha = 1.0f;
-        mContext = context;
-        mTimeBar = new TimeBar(context);
-        mPathBar = new PathBarLayer();
+        if (sTimeBar == null) {
+            sTimeBar = new TimeBar(context);
+            sPathBar = new PathBarLayer();
+        }
         mTopRightButton.setSize((int) (100 * Gallery.PIXEL_DENSITY), (int) (94 * Gallery.PIXEL_DENSITY));
 
         mZoomInButton.setSize(43 * Gallery.PIXEL_DENSITY, 43 * Gallery.PIXEL_DENSITY);
@@ -118,13 +120,13 @@ public final class HudLayer extends Layer {
         // The Share submenu is populated dynamically when opened.
         Resources resources = context.getResources();
         PopupMenu.Option[] deleteOptions = {
-                new PopupMenu.Option(mContext.getResources().getString(R.string.confirm_delete), resources
+                new PopupMenu.Option(context.getResources().getString(R.string.confirm_delete), resources
                         .getDrawable(R.drawable.icon_delete), new Runnable() {
                     public void run() {
                         deleteSelection();
                     }
                 }),
-                new PopupMenu.Option(mContext.getResources().getString(R.string.cancel), resources
+                new PopupMenu.Option(context.getResources().getString(R.string.cancel), resources
                         .getDrawable(R.drawable.icon_cancel), new Runnable() {
                     public void run() {
 
@@ -132,17 +134,17 @@ public final class HudLayer extends Layer {
                 }), };
         mSelectionMenuBottom = new MenuBar(context);
 
-        MenuBar.Menu shareMenu = new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.share)).icon(
+        MenuBar.Menu shareMenu = new MenuBar.Menu.Builder(context.getResources().getString(R.string.share)).icon(
                 R.drawable.icon_share).onSelect(new Runnable() {
             public void run() {
                 updateShareMenu();
             }
         }).build();
 
-        MenuBar.Menu deleteMenu = new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.delete)).icon(
+        MenuBar.Menu deleteMenu = new MenuBar.Menu.Builder(context.getResources().getString(R.string.delete)).icon(
                 R.drawable.icon_delete).options(deleteOptions).build();
 
-        MenuBar.Menu moreMenu = new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.more)).icon(
+        MenuBar.Menu moreMenu = new MenuBar.Menu.Builder(context.getResources().getString(R.string.more)).icon(
                 R.drawable.icon_more).onSelect(new Runnable() {
             public void run() {
                 buildMoreOptions();
@@ -155,19 +157,19 @@ public final class HudLayer extends Layer {
         mSelectionMenuBottom.setMenus(mNormalBottomMenu);
         mSelectionMenuTop = new MenuBar(context);
         mSelectionMenuTop.setMenus(new MenuBar.Menu[] {
-                new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.select_all)).onSelect(new Runnable() {
+                new MenuBar.Menu.Builder(context.getResources().getString(R.string.select_all)).onSelect(new Runnable() {
                     public void run() {
                         mGridLayer.selectAll();
                     }
                 }).build(), new MenuBar.Menu.Builder("").build(),
-                new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.deselect_all)).onSelect(new Runnable() {
+                new MenuBar.Menu.Builder(context.getResources().getString(R.string.deselect_all)).onSelect(new Runnable() {
                     public void run() {
                         mGridLayer.deselectOrCancelSelectMode();
                     }
                 }).build() });
         mFullscreenMenu = new MenuBar(context);
         mFullscreenMenu.setMenus(new MenuBar.Menu[] {
-                new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.slideshow)).icon(R.drawable.icon_play)
+                new MenuBar.Menu.Builder(context.getResources().getString(R.string.slideshow)).icon(R.drawable.icon_play)
                         .onSingleTapUp(new Runnable() {
                             public void run() {
                                 if (getAlpha() == 1.0f)
@@ -176,7 +178,7 @@ public final class HudLayer extends Layer {
                                     setAlpha(1.0f);
                             }
                         }).build(), /* new MenuBar.Menu.Builder("").build(), */
-                new MenuBar.Menu.Builder(mContext.getResources().getString(R.string.menu)).icon(R.drawable.icon_more)
+                new MenuBar.Menu.Builder(context.getResources().getString(R.string.menu)).icon(R.drawable.icon_more)
                         .onSingleTapUp(new Runnable() {
                             public void run() {
                                 if (getAlpha() == 1.0f)
@@ -186,6 +188,13 @@ public final class HudLayer extends Layer {
                             }
                         }).build() });
     }
+    
+    public void setContext(Context context) {
+        if (mContext != context) {
+            mContext = context;
+            sTimeBar.regenerateStringsForContext(context);
+        }
+    }
 
     private void buildMoreOptions() {
         ArrayList<MediaBucket> buckets = mGridLayer.getSelectedBuckets();
@@ -407,8 +416,8 @@ public final class HudLayer extends Layer {
         final float height = mHeight;
         closeSelectionMenu();
 
-        mTimeBar.setPosition(0f, height - TimeBar.HEIGHT * Gallery.PIXEL_DENSITY);
-        mTimeBar.setSize(width, TimeBar.HEIGHT * Gallery.PIXEL_DENSITY);
+        sTimeBar.setPosition(0f, height - TimeBar.HEIGHT * Gallery.PIXEL_DENSITY);
+        sTimeBar.setSize(width, TimeBar.HEIGHT * Gallery.PIXEL_DENSITY);
         mSelectionMenuTop.setPosition(0f, 0);
         mSelectionMenuTop.setSize(width, MenuBar.HEIGHT * Gallery.PIXEL_DENSITY);
         mSelectionMenuBottom.setPosition(0f, height - MenuBar.HEIGHT * Gallery.PIXEL_DENSITY);
@@ -417,7 +426,7 @@ public final class HudLayer extends Layer {
         mFullscreenMenu.setPosition(0f, height - MenuBar.HEIGHT * Gallery.PIXEL_DENSITY);
         mFullscreenMenu.setSize(width, MenuBar.HEIGHT * Gallery.PIXEL_DENSITY);
 
-        mPathBar.setPosition(0f, -4f * Gallery.PIXEL_DENSITY);
+        sPathBar.setPosition(0f, -4f * Gallery.PIXEL_DENSITY);
         computeSizeForPathbar();
 
         mTopRightButton.setPosition(width - mTopRightButton.getWidth(), 0f);
@@ -429,12 +438,12 @@ public final class HudLayer extends Layer {
         float pathBarWidth = mWidth
                 - ((mGridLayer.getState() == GridLayer.STATE_FULL_SCREEN) ? 32 * Gallery.PIXEL_DENSITY
                         : 120 * Gallery.PIXEL_DENSITY);
-        mPathBar.setSize(pathBarWidth, FloatMath.ceil(39 * Gallery.PIXEL_DENSITY));
-        mPathBar.recomputeComponents();
+        sPathBar.setSize(pathBarWidth, FloatMath.ceil(39 * Gallery.PIXEL_DENSITY));
+        sPathBar.recomputeComponents();
     }
 
     public void setFeed(MediaFeed feed, int state, boolean needsLayout) {
-        mTimeBar.setFeed(feed, state, needsLayout);
+        sTimeBar.setFeed(feed, state, needsLayout);
     }
 
     public void onGridStateChanged() {
@@ -442,8 +451,9 @@ public final class HudLayer extends Layer {
     }
 
     private void updateViews() {
+        if (mGridLayer == null)
+            return;
         final int state = mGridLayer.getState();
-
         // Show the selection menu in selection mode.
         final boolean selectionMode = mMode == MODE_SELECT;
         final boolean fullscreenMode = state == GridLayer.STATE_FULL_SCREEN;
@@ -455,11 +465,11 @@ public final class HudLayer extends Layer {
         mZoomOutButton.setHidden(mFullscreenMenu.isHidden());
 
         // Show the time bar in stack and grid states, except in selection mode.
-        mTimeBar.setHidden(fullscreenMode || selectionMode || stackMode);
+        sTimeBar.setHidden(fullscreenMode || selectionMode || stackMode);
         // mTimeBar.setHidden(selectionMode || (state != GridLayer.STATE_TIMELINE && state != GridLayer.STATE_GRID_VIEW));
 
         // Hide the path bar and top-right button in selection mode.
-        mPathBar.setHidden(selectionMode);
+        sPathBar.setHidden(selectionMode);
         mTopRightButton.setHidden(selectionMode || fullscreenMode);
         computeSizeForPathbar();
 
@@ -495,11 +505,11 @@ public final class HudLayer extends Layer {
     }
 
     public TimeBar getTimeBar() {
-        return mTimeBar;
+        return sTimeBar;
     }
 
     public PathBarLayer getPathBar() {
-        return mPathBar;
+        return sPathBar;
     }
 
     public GridLayer getGridLayer() {
@@ -566,12 +576,12 @@ public final class HudLayer extends Layer {
         mTopRightButton.generate(view, lists);
         mZoomInButton.generate(view, lists);
         mZoomOutButton.generate(view, lists);
-        mTimeBar.generate(view, lists);
+        sTimeBar.generate(view, lists);
         mSelectionMenuTop.generate(view, lists);
         mSelectionMenuBottom.generate(view, lists);
         mFullscreenMenu.generate(view, lists);
-        mPathBar.generate(view, lists);
-        //mLoadingLayer.generate(view, lists);
+        sPathBar.generate(view, lists);
+        // mLoadingLayer.generate(view, lists);
         mView = view;
     }
 
@@ -609,6 +619,7 @@ public final class HudLayer extends Layer {
 
     void reset() {
         mLoadingLayer.reset();
+        sTimeBar.regenerateStringsForContext(mContext);
     }
 
     public void fullscreenSelectionChanged(MediaItem item, int index, int count) {
@@ -622,12 +633,7 @@ public final class HudLayer extends Layer {
         mCachedCaption = item.mCaption;
         mCachedPosition = location;
         mCachedCurrentLabel = location;
-        mPathBar.changeLabel(location);
-        // String displayString = DateFormat.format("h:mmaa MMM dd yyyy", item.dateTaken).toString();
-        // Menu menu = new
-        // MenuBar.Menu.Builder(displayString).StringTexture.Config(MenuBar.MENU_TITLE_STYLE_TEXT).resizeToAccomodate()
-        // .build();
-        // mFullscreenMenu.updateMenu(menu, 1);
+        sPathBar.changeLabel(location);
     }
 
     private void updateShareMenu() {
@@ -739,7 +745,7 @@ public final class HudLayer extends Layer {
 
     public void swapFullscreenLabel() {
         mCachedCurrentLabel = (mCachedCurrentLabel == mCachedCaption || mCachedCaption == null) ? mCachedPosition : mCachedCaption;
-        mPathBar.changeLabel(mCachedCurrentLabel);
+        sPathBar.changeLabel(mCachedCurrentLabel);
     }
 
     public void clear() {
@@ -747,7 +753,7 @@ public final class HudLayer extends Layer {
     }
 
     public void shutDown() {
-        mGridLayer = null;
+        
     }
 
     public void enterSelectionMode() {

--- a/src/com/cooliris/media/ImageManager.java
+++ b/src/com/cooliris/media/ImageManager.java
@@ -280,9 +280,9 @@ public class ImageManager {
         return false;
     }
 
-    private static Cursor query(ContentResolver resolver, Uri uri,
-            String[] projection, String selection, String[] selectionArgs,
-            String sortOrder) {
+    private static final Cursor query(final ContentResolver resolver, final Uri uri,
+            final String[] projection, final String selection, final String[] selectionArgs,
+            final String sortOrder) {
         try {
             if (resolver == null) {
                 return null;
@@ -295,9 +295,9 @@ public class ImageManager {
 
     }
 
-    public static boolean isMediaScannerScanning(ContentResolver cr) {
+    public static final boolean isMediaScannerScanning(final ContentResolver cr) {
         boolean result = false;
-        Cursor cursor = query(cr, MediaStore.getMediaScannerUri(),
+        final Cursor cursor = query(cr, MediaStore.getMediaScannerUri(),
                 new String [] {MediaStore.MEDIA_SCANNER_VOLUME},
                 null, null, null);
         if (cursor != null) {

--- a/src/com/cooliris/media/LocalDataSource.java
+++ b/src/com/cooliris/media/LocalDataSource.java
@@ -94,6 +94,9 @@ public final class LocalDataSource implements DataSource {
     }
 
     public void shutdown() {
+        if (ImageManager.isMediaScannerScanning(mContext.getContentResolver())) {
+            stopListeners();
+        }
     }
     
     private void stopListeners() {
@@ -113,7 +116,6 @@ public final class LocalDataSource implements DataSource {
         Log.i(TAG, "Refreshing local data source");
         Gallery.NEEDS_REFRESH = true;
         if (feed.getMediaSet(setIdToUse) == null) {
-            Log.i(TAG, "We check to see if there are any items with this bucket id in the database.");
             if (!CacheService.setHasItems(mContext.getContentResolver(), setIdToUse))
                 return;
             MediaSet mediaSet = feed.addMediaSet(setIdToUse, this);

--- a/src/com/cooliris/media/MediaFeed.java
+++ b/src/com/cooliris/media/MediaFeed.java
@@ -23,6 +23,7 @@ public final class MediaFeed implements Runnable {
     private Listener mListener;
     private DataSource mDataSource;
     private boolean mListenerNeedsUpdate = false;
+    private boolean mMediaFeedNeedsToRun = false;
     private MediaSet mSingleWrapper = new MediaSet();
     private boolean mInClusteringMode = false;
     private HashMap<MediaSet, MediaClustering> mClusterSets = new HashMap<MediaSet, MediaClustering>(32);
@@ -50,7 +51,7 @@ public final class MediaFeed implements Runnable {
         mSingleWrapper.setNumExpectedItems(1);
         mLoading = true;
     }
-    
+
     public void shutdown() {
         if (mDataSourceThread != null) {
             mDataSource.shutdown();
@@ -83,13 +84,16 @@ public final class MediaFeed implements Runnable {
     }
 
     public void setVisibleRange(int begin, int end) {
-        mVisibleRange.begin = begin;
-        mVisibleRange.end = end;
-        int numItems = 96;
-        int numItemsBy2 = numItems / 2;
-        int numItemsBy4 = numItems / 4;
-        mBufferedRange.begin = (begin / numItemsBy2) * numItemsBy2 - numItemsBy4;
-        mBufferedRange.end = mBufferedRange.begin + numItems;
+        if (begin != mVisibleRange.begin || end != mVisibleRange.end) {
+            mVisibleRange.begin = begin;
+            mVisibleRange.end = end;
+            int numItems = 96;
+            int numItemsBy2 = numItems / 2;
+            int numItemsBy4 = numItems / 4;
+            mBufferedRange.begin = (begin / numItemsBy2) * numItemsBy2 - numItemsBy4;
+            mBufferedRange.end = mBufferedRange.begin + numItems;
+            mMediaFeedNeedsToRun = true;
+        }
     }
 
     public void setFilter(MediaFilter filter) {
@@ -98,6 +102,7 @@ public final class MediaFeed implements Runnable {
         if (mListener != null) {
             mListener.onFeedAboutToChange(this);
         }
+        mMediaFeedNeedsToRun = true;
     }
 
     public void removeFilter() {
@@ -107,19 +112,24 @@ public final class MediaFeed implements Runnable {
             mListener.onFeedAboutToChange(this);
             updateListener(true);
         }
+        mMediaFeedNeedsToRun = true;
     }
 
     public ArrayList<MediaSet> getMediaSets() {
         return mMediaSets;
     }
 
-    public synchronized MediaSet getMediaSet(final long setId) {
+    public MediaSet getMediaSet(final long setId) {
         if (setId != Shared.INVALID) {
-            int mMediaSetsSize = mMediaSets.size();
-            for (int i = 0; i < mMediaSetsSize; i++) {
-                if (mMediaSets.get(i).mId == setId) {
-                    return mMediaSets.get(i);
+            try {
+                int mMediaSetsSize = mMediaSets.size();
+                for (int i = 0; i < mMediaSetsSize; i++) {
+                    if (mMediaSets.get(i).mId == setId) {
+                        return mMediaSets.get(i);
+                    }
                 }
+            } catch (Exception e) {
+                return null;
             }
         }
         return null;
@@ -133,6 +143,10 @@ public final class MediaFeed implements Runnable {
         MediaSet mediaSet = new MediaSet(dataSource);
         mediaSet.mId = setId;
         mMediaSets.add(mediaSet);
+        if (mDataSourceThread != null && !mDataSourceThread.isAlive()) {
+            mDataSourceThread.start();
+        }
+        mMediaFeedNeedsToRun = true;
         return mediaSet;
     }
 
@@ -161,7 +175,7 @@ public final class MediaFeed implements Runnable {
     public void addItemToMediaSet(MediaItem item, MediaSet mediaSet) {
         item.mParentMediaSet = mediaSet;
         mediaSet.addItem(item);
-        synchronized (this) {
+        synchronized (mClusterSets) {
             if (item.mClusteringState == MediaItem.NOT_CLUSTERED) {
                 MediaClustering clustering = mClusterSets.get(mediaSet);
                 if (clustering == null) {
@@ -173,6 +187,7 @@ public final class MediaFeed implements Runnable {
                 item.mClusteringState = MediaItem.CLUSTERED;
             }
         }
+        mMediaFeedNeedsToRun = true;
     }
 
     public void performOperation(final int operation, final ArrayList<MediaBucket> mediaBuckets, final Object data) {
@@ -183,7 +198,6 @@ public final class MediaFeed implements Runnable {
         }
         if (operation == OPERATION_DELETE && mListener != null) {
             mListener.onFeedAboutToChange(this);
-
         }
         Thread operationThread = new Thread(new Runnable() {
             public void run() {
@@ -214,6 +228,7 @@ public final class MediaFeed implements Runnable {
                         }
                     }
                     updateListener(true);
+                    mMediaFeedNeedsToRun = true;
                     if (mDataSource != null) {
                         mDataSource.performOperation(OPERATION_DELETE, mediaBuckets, null);
                     }
@@ -228,16 +243,18 @@ public final class MediaFeed implements Runnable {
 
     public void removeMediaSet(MediaSet set) {
         mMediaSets.remove(set);
+        mMediaFeedNeedsToRun = true;
     }
 
     private void removeItemFromMediaSet(MediaItem item, MediaSet mediaSet) {
         mediaSet.removeItem(item);
-        synchronized (this) {
+        synchronized (mClusterSets) {
             MediaClustering clustering = mClusterSets.get(mediaSet);
             if (clustering != null) {
                 clustering.removeItemFromClustering(item);
             }
         }
+        mMediaFeedNeedsToRun = true;
     }
 
     public void updateListener(boolean needsLayout) {
@@ -311,7 +328,7 @@ public final class MediaFeed implements Runnable {
     public boolean getWaitingForMediaScanner() {
         return mWaitingForMediaScanner;
     }
-    
+
     public boolean isLoading() {
         return mLoading;
     }
@@ -319,6 +336,8 @@ public final class MediaFeed implements Runnable {
     public void start() {
         final MediaFeed feed = this;
         mLoading = true;
+        mDataSourceThread = new Thread(this);
+        mDataSourceThread.setName("MediaFeed");
         mAlbumSourceThread = new Thread(new Runnable() {
             public void run() {
                 if (mContext == null)
@@ -326,6 +345,9 @@ public final class MediaFeed implements Runnable {
                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                 DataSource dataSource = mDataSource;
                 // We must wait while the SD card is mounted or the MediaScanner is running.
+                if (dataSource != null) {
+                    dataSource.loadMediaSets(feed);
+                }
                 mWaitingForMediaScanner = false;
                 while (ImageManager.isMediaScannerScanning(mContext.getContentResolver())) {
                     // MediaScanner is still running, wait
@@ -341,19 +363,16 @@ public final class MediaFeed implements Runnable {
                 }
                 if (mWaitingForMediaScanner) {
                     showToast(mContext.getResources().getString(R.string.loading_new), Toast.LENGTH_LONG);
-                }
-                mWaitingForMediaScanner = false;
-                if (dataSource != null) {
-                    dataSource.loadMediaSets(feed);
+                    mWaitingForMediaScanner = false;
+                    if (dataSource != null) {
+                        dataSource.loadMediaSets(feed);
+                    }
                 }
                 mLoading = false;
             }
         });
         mAlbumSourceThread.setName("MediaSets");
         mAlbumSourceThread.start();
-        mDataSourceThread = new Thread(this);
-        mDataSourceThread.setName("MediaFeed");
-        mDataSourceThread.start();
     }
 
     private void showToast(final String string, final int duration) {
@@ -361,7 +380,7 @@ public final class MediaFeed implements Runnable {
     }
 
     private void showToast(final String string, final int duration, final boolean centered) {
-        if (mContext != null && !((Gallery)mContext).isPaused()) {
+        if (mContext != null && !((Gallery) mContext).isPaused()) {
             ((Gallery) mContext).getHandler().post(new Runnable() {
                 public void run() {
                     if (mContext != null) {
@@ -378,10 +397,10 @@ public final class MediaFeed implements Runnable {
 
     public void run() {
         DataSource dataSource = mDataSource;
-        int sleepMs = 100;
+        int sleepMs = 10;
         Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
         if (dataSource != null) {
-            while (Thread.interrupted() == false) {
+            while (!Thread.interrupted()) {
                 if (mListenerNeedsUpdate) {
                     mListenerNeedsUpdate = false;
                     if (mListener != null)
@@ -392,13 +411,21 @@ public final class MediaFeed implements Runnable {
                         return;
                     }
                 } else {
+                    if (mWaitingForMediaScanner) {
+                        synchronized (mMediaSets) {
+                            mMediaSets.clear();
+                        }
+                    }
                     try {
                         Thread.sleep(sleepMs);
                     } catch (InterruptedException e) {
                         return;
                     }
                 }
-                sleepMs = 100;
+                sleepMs = 300;
+                if (!mMediaFeedNeedsToRun)
+                    continue;
+                mMediaFeedNeedsToRun = false;
                 ArrayList<MediaSet> mediaSets = mMediaSets;
                 synchronized (mediaSets) {
                     int expandedSetIndex = mExpandedMediaSetIndex;
@@ -415,13 +442,6 @@ public final class MediaFeed implements Runnable {
                             if (i >= visibleRange.begin && i <= visibleRange.end && scanMediaSets) {
                                 MediaSet set = mediaSets.get(i);
                                 int numItemsLoaded = set.mNumItemsLoaded;
-                                if (!set.setContainsValidItems()) {
-                                    mediaSets.remove(set);
-                                    if (mListener != null) {
-                                        mListener.onFeedChanged(this, false);
-                                    }
-                                    break;
-                                }
                                 if (numItemsLoaded < set.getNumExpectedItems() && numItemsLoaded < 8) {
                                     dataSource.loadItemsForSet(this, set, numItemsLoaded, 8);
                                     if (set.getNumExpectedItems() == 0) {
@@ -434,6 +454,13 @@ public final class MediaFeed implements Runnable {
                                     sleepMs = 100;
                                     scanMediaSets = false;
                                 }
+                                if (!set.setContainsValidItems()) {
+                                    mediaSets.remove(set);
+                                    if (mListener != null) {
+                                        mListener.onFeedChanged(this, false);
+                                    }
+                                    break;
+                                }
                             }
                         }
                         numSets = mMediaSets.size();
@@ -455,7 +482,7 @@ public final class MediaFeed implements Runnable {
                                         scanMediaSets = false;
                                     }
                                 }
-                            } else if (i < bufferedRange.begin || i > bufferedRange.end){
+                            } else if (i < bufferedRange.begin || i > bufferedRange.end) {
                                 // Purge this set to its initial status.
                                 MediaClustering clustering = mClusterSets.get(set);
                                 if (clustering != null) {
@@ -555,6 +582,7 @@ public final class MediaFeed implements Runnable {
             // PicasaService.requestSync(mContext, PicasaService.TYPE_ALBUM_PHOTOS, set.mPicasaAlbumId);
         }
         updateListener(true);
+        mMediaFeedNeedsToRun = true;
     }
 
     public boolean canExpandSet(int slotIndex) {
@@ -583,6 +611,7 @@ public final class MediaFeed implements Runnable {
                 mListener.onFeedAboutToChange(this);
             }
             updateListener(true);
+            mMediaFeedNeedsToRun = true;
         }
         return retVal;
     }
@@ -591,6 +620,7 @@ public final class MediaFeed implements Runnable {
         if (mInClusteringMode) {
             // Disable clustering.
             mInClusteringMode = false;
+            mMediaFeedNeedsToRun = true;
             return true;
         }
         return false;
@@ -617,7 +647,7 @@ public final class MediaFeed implements Runnable {
         }
         if (setToUse != null) {
             MediaClustering clustering = null;
-            synchronized (this) {
+            synchronized (mClusterSets) {
                 // Make sure the computation is completed to the end.
                 clustering = mClusterSets.get(setToUse);
                 if (clustering != null) {
@@ -627,6 +657,7 @@ public final class MediaFeed implements Runnable {
                 }
             }
             mInClusteringMode = true;
+            mMediaFeedNeedsToRun = true;
             updateListener(true);
         }
     }
@@ -660,6 +691,7 @@ public final class MediaFeed implements Runnable {
                 mediaSets.set(i - 1, setEnd);
             }
         }
+        mMediaFeedNeedsToRun = true;
     }
 
     public MediaSet replaceMediaSet(long setId, DataSource dataSource) {
@@ -675,9 +707,10 @@ public final class MediaFeed implements Runnable {
                 break;
             }
         }
+        mMediaFeedNeedsToRun = true;
         return mediaSet;
     }
-    
+
     public void setSingleImageMode(boolean singleImageMode) {
         mSingleImageMode = singleImageMode;
     }

--- a/src/com/cooliris/media/MediaItem.java
+++ b/src/com/cooliris/media/MediaItem.java
@@ -91,11 +91,13 @@ public final class MediaItem {
     public boolean isPicassaItem() {
         return (mParentMediaSet != null && mParentMediaSet.isPicassaAlbum());
     }
+    
+    private static final String VIDEO = "video/";
 
     public int getMediaType() {
         if (mMediaType == -1) {
             // Default to image if mMimetype is null or not video.
-            mMediaType = (mMimeType != null && mMimeType.startsWith("video/")) ? MediaItem.MEDIA_TYPE_VIDEO : MediaItem.MEDIA_TYPE_IMAGE;
+            mMediaType = (mMimeType != null && mMimeType.startsWith(VIDEO)) ? MediaItem.MEDIA_TYPE_VIDEO : MediaItem.MEDIA_TYPE_IMAGE;
         }
         return mMediaType;
     }

--- a/src/com/cooliris/media/MediaItemTexture.java
+++ b/src/com/cooliris/media/MediaItemTexture.java
@@ -24,6 +24,7 @@ public final class MediaItemTexture extends Texture {
     private final MediaItem mItem;
     private Context mContext;
     private boolean mIsRetrying;
+    private boolean mCached;
 
     public static final class Config {
         public int thumbnailWidth;
@@ -34,23 +35,10 @@ public final class MediaItemTexture extends Texture {
         mConfig = config;
         mContext = context;
         mItem = item;
+        mCached = computeCache();
     }
     
-    @Override
-    public boolean isUncachedVideo() {
-        if (isCached())
-            return false;
-        if (mItem.mParentMediaSet == null || mItem.mMimeType == null)
-            return false;
-        if (mItem.mParentMediaSet.mPicasaAlbumId == Shared.INVALID && mItem.mMimeType.contains("video")) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public boolean isCached() {
+    private boolean computeCache() {
         final Config config = mConfig;
         final MediaItem item = mItem;
         DiskCache cache = null;
@@ -61,7 +49,7 @@ public final class MediaItemTexture extends Texture {
                 if (item.mMimeType.contains("video")) {
                     cache = LocalDataSource.sThumbnailCacheVideo;
                 }
-            } 
+            }
         }
         if (cache == null) {
             return false;
@@ -72,6 +60,24 @@ public final class MediaItemTexture extends Texture {
         }
     }
 
+    @Override
+    public boolean isUncachedVideo() {
+        if (isCached())
+            return false;
+        if (mItem.mParentMediaSet == null || mItem.mMimeType == null)
+            return false;
+        if (mItem.mParentMediaSet.mPicasaAlbumId == Shared.INVALID && mItem.mMimeType.contains("video")) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isCached() {
+        return mCached;
+    }
+
     protected Bitmap load(RenderView view) {
 
         final Config config = mConfig;
@@ -112,11 +118,15 @@ public final class MediaItemTexture extends Texture {
                     new Thread() {
                         public void run() {
                             try {
-                            Thread.sleep(5000);
+                                Thread.sleep(5000);
                             } catch (InterruptedException e) {
                                 ;
                             }
-                            MediaStore.Video.Thumbnails.cancelThumbnailRequest(mContext.getContentResolver(), mItem.mId);
+                            try {
+                                MediaStore.Video.Thumbnails.cancelThumbnailRequest(mContext.getContentResolver(), mItem.mId);
+                            } catch (Exception e) {
+                                ;
+                            }
                         }
                     }.start();
                     retVal = MediaStore.Video.Thumbnails.getThumbnail(mContext.getContentResolver(), mItem.mId,
@@ -169,7 +179,7 @@ public final class MediaItemTexture extends Texture {
                     item.mThumbnailFocusY = dataInput.readShort();
                     // Decode the thumbnail.
                     final BitmapFactory.Options options = new BitmapFactory.Options();
-                    options.inDither = true;
+                    options.inDither = false;
                     options.inScaled = false;
                     options.inPreferredConfig = Bitmap.Config.RGB_565;
                     final Bitmap bitmap = BitmapFactory.decodeByteArray(data, CACHE_HEADER_SIZE, data.length - CACHE_HEADER_SIZE,

--- a/src/com/cooliris/media/MenuBar.java
+++ b/src/com/cooliris/media/MenuBar.java
@@ -142,7 +142,6 @@ public final class MenuBar extends Layer implements PopupMenu.Listener {
                 view.draw2D(icon, menu.x + offset, iconY);
             }
             float titleY = y + (height - MENU_TITLE_STYLE.height) / 2 + 1;
-            //Log.i("MENUBAR", "Drawing label (" + title.getWidth() + ", " + title.getHeight() + ", " + title.mNormalizedWidth + ")");
             view.draw2D(titleTexture, menu.x + offset + iconWidth, titleY);
         }
     }

--- a/src/com/cooliris/media/PathBarLayer.java
+++ b/src/com/cooliris/media/PathBarLayer.java
@@ -260,4 +260,8 @@ public final class PathBarLayer extends Layer {
     public int getNumLevels() {
         return mComponents.size();
     }
+
+    public void clear() {
+        mComponents.clear();
+    }
 }

--- a/src/com/cooliris/media/PicasaDataSource.java
+++ b/src/com/cooliris/media/PicasaDataSource.java
@@ -189,7 +189,6 @@ public final class PicasaDataSource implements DataSource {
                         for (int j = 0, numItems = items.size(); j != numItems; ++j) {
                             MediaItem item = items.get(j);
                             if (item != null) {
-                                Log.i(TAG, "Deleting picasa photo " + item.mContentUri);
                                 String itemUri = PicasaContentProvider.PHOTOS_URI + "/" + item.mId; 
                                 client.delete(Uri.parse(itemUri), null, null);
                             }

--- a/src/com/cooliris/media/RenderView.java
+++ b/src/com/cooliris/media/RenderView.java
@@ -31,7 +31,7 @@ import android.view.SurfaceHolder;
 public final class RenderView extends GLSurfaceView implements GLSurfaceView.Renderer, SensorEventListener {
     private static final String TAG = "RenderView";
     private static final int NUM_TEXTURE_LOAD_THREADS = 4;
-    private static final int MAX_LOADING_COUNT = 8;
+    private static final int MAX_LOADING_COUNT = 128;
 
     private static final int EVENT_NONE = 0;
     // private static final int EVENT_TOUCH = 1;
@@ -46,7 +46,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
     private RootLayer mRootLayer = null;
     private boolean mListsDirty = false;
-    private final Lists mLists = new Lists();
+    private static final Lists sLists = new Lists();
 
     private Layer mTouchEventTarget = null;
 
@@ -56,16 +56,18 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     private volatile boolean mPendingSensorEvent = false;
 
     private int mLoadingCount = 0;
-    private final Deque<Texture> mLoadInputQueue = new Deque<Texture>();
-    private final Deque<Texture> mLoadInputQueueCached = new Deque<Texture>();
-    private final Deque<Texture> mLoadInputQueueVideo = new Deque<Texture>();
-    private final Deque<Texture> mLoadOutputQueue = new Deque<Texture>();
+    private static final Deque<Texture> sLoadInputQueue = new Deque<Texture>();
+    private static final Deque<Texture> sLoadInputQueueCached = new Deque<Texture>();
+    private static final Deque<Texture> sLoadInputQueueVideo = new Deque<Texture>();
+    private static final Deque<Texture> sLoadOutputQueue = new Deque<Texture>();
+    private static TextureLoadThread sCachedTextureLoadThread = null;
+    private static TextureLoadThread sVideoTextureLoadThread = null;
+    private static final TextureLoadThread[] sTextureLoadThreads = new TextureLoadThread[NUM_TEXTURE_LOAD_THREADS];
+
     private final Deque<MotionEvent> mTouchEventQueue = new Deque<MotionEvent>();
     private final DirectLinkedList<TextureReference> mActiveTextureList = new DirectLinkedList<TextureReference>();
+    @SuppressWarnings("unchecked")
     private final ReferenceQueue mUnreferencedTextureQueue = new ReferenceQueue();
-    private final TextureLoadThread[] mTextureLoadThreads = new TextureLoadThread[NUM_TEXTURE_LOAD_THREADS];
-    private TextureLoadThread mCachedTextureLoadThread = null;
-    private TextureLoadThread mVideoTextureLoadThread = null;
 
     // Frame time in milliseconds and delta since last frame in seconds. Uses SystemClock.getUptimeMillis().
     private long mFrameTime = 0;
@@ -77,10 +79,14 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     private final SparseArray<ResourceTexture> sCacheUnscaled = new SparseArray<ResourceTexture>();
 
     private boolean mFirstDraw;
+    // The cached texture that is bound to Texture Unit 0.
+    // We need to reset this to null whenever the active texture unit changes.
+    private Texture mBoundTexture;
 
     // Weak reference to a texture that stores the associated texture ID.
     private static final class TextureReference extends WeakReference<Texture> {
-        public TextureReference(Texture texture, GL11 gl, ReferenceQueue<Texture> referenceQueue, int textureId) {
+        @SuppressWarnings("unchecked")
+        public TextureReference(Texture texture, GL11 gl, ReferenceQueue referenceQueue, int textureId) {
             super(texture, referenceQueue);
             this.textureId = textureId;
             this.gl = gl;
@@ -107,24 +113,25 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         }
     }
 
-    public RenderView(Context context) {
+    public RenderView(final Context context) {
         super(context);
         setBackgroundDrawable(null);
         setFocusable(true);
         setEGLConfigChooser(true);
         setRenderer(this);
         mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
-
-        for (int i = 0; i != NUM_TEXTURE_LOAD_THREADS; ++i) {
-            TextureLoadThread thread = new TextureLoadThread();
-            if (i == 0) {
-                mCachedTextureLoadThread = thread;
-            }
-            if (i == 1) {
-                mVideoTextureLoadThread = thread;
+        if (sCachedTextureLoadThread == null) {
+            for (int i = 0; i != NUM_TEXTURE_LOAD_THREADS; ++i) {
+                TextureLoadThread thread = new TextureLoadThread();
+                if (i == 0) {
+                    sCachedTextureLoadThread = thread;
+                }
+                if (i == 1) {
+                    sVideoTextureLoadThread = thread;
+                }
+                sTextureLoadThreads[i] = thread;
+                thread.start();
             }
-            mTextureLoadThreads[i] = thread;
-            thread.start();
         }
     }
 
@@ -241,11 +248,13 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
     public boolean bind(Texture texture) {
         if (texture != null) {
+            if (texture == mBoundTexture)
+                return true;
             switch (texture.mState) {
             case Texture.STATE_UNLOADED:
                 if (texture.getClass().equals(ResourceTexture.class)) {
                     loadTexture(texture);
-                    return true;
+                    return false;
                 }
                 if (mLoadingCount < MAX_LOADING_COUNT) {
                     queueLoad(texture, false);
@@ -253,6 +262,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
                 break;
             case Texture.STATE_LOADED:
                 mGL.glBindTexture(GL11.GL_TEXTURE_2D, texture.mId);
+                mBoundTexture = texture;
                 return true;
             default:
                 break;
@@ -308,8 +318,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         texture.mState = Texture.STATE_LOADING;
 
         // Push the texture onto the load input queue.
-        Deque<Texture> inputQueue = (texture.isCached()) ? mLoadInputQueueCached : mLoadInputQueue;
-        inputQueue = (texture.isUncachedVideo()) ? mLoadInputQueueVideo : mLoadInputQueue;
+        Deque<Texture> inputQueue = (texture.isUncachedVideo()) ? sLoadInputQueueVideo : (texture.isCached()) ? sLoadInputQueueCached : sLoadInputQueue;;
         synchronized (inputQueue) {
             if (highPriority) {
                 inputQueue.addFirst(texture);
@@ -351,6 +360,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         boolean bind = true;
         bind &= bind(from);
         gl.glActiveTexture(GL11.GL_TEXTURE1);
+        mBoundTexture = null;
         bind &= bind(to);
         if (!bind) {
             return false;
@@ -385,6 +395,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
         // Switch back to the default texture unit.
         gl.glActiveTexture(GL11.GL_TEXTURE0);
+        mBoundTexture = null;
     }
 
     public void drawMixed2D(Texture from, Texture to, float ratio, float x, float y, float z, float width, float height) {
@@ -393,6 +404,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         // Bind "from" and "to" to TEXTURE0 and TEXTURE1, respectively.
         if (bind(from)) {
             gl.glActiveTexture(GL11.GL_TEXTURE1);
+            mBoundTexture = null;
             if (bind(to)) {
                 // Enable TEXTURE1.
                 gl.glEnable(GL11.GL_TEXTURE_2D);
@@ -423,6 +435,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
             // Switch back to the default texture unit.
             gl.glActiveTexture(GL11.GL_TEXTURE0);
+            mBoundTexture = null;
         }
     }
 
@@ -445,7 +458,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
             }
             mActiveTextureList.remove(textureReference.activeListEntry);
         }
-        Deque<Texture> outputQueue = mLoadOutputQueue;
+        Deque<Texture> outputQueue = sLoadOutputQueue;
         Texture texture;
         do {
             // Upload loaded textures to the GPU one frame at a time.
@@ -467,6 +480,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     private void uploadTexture(Texture texture, int[] textureId) {
         Bitmap bitmap = texture.mBitmap;
         GL11 gl = mGL;
+        int glError = GL11.GL_NO_ERROR;
         if (bitmap != null) {
             final int width = texture.mWidth;
             final int height = texture.mHeight;
@@ -474,41 +488,38 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
             // Define a vertically flipped crop rectangle for OES_draw_texture.
             int[] cropRect = { 0, height, width, -height };
 
-            // Handle texture upload failures
-            int numTextureFails = 0;
-            boolean textureFail = false;
-            do {
-                textureFail = false;
-                // Upload the bitmap to a new texture.
-                gl.glGenTextures(1, textureId, 0);
-                gl.glBindTexture(GL11.GL_TEXTURE_2D, textureId[0]);
-                gl.glTexParameteriv(GL11.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES, cropRect, 0);
-                gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP_TO_EDGE);
-                gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP_TO_EDGE);
-                gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
-                gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
-                GLUtils.texImage2D(GL11.GL_TEXTURE_2D, 0, bitmap, 0);
-                int glError = gl.glGetError();
-                if (glError == GL11.GL_OUT_OF_MEMORY) {
-                    Log.i(TAG, "Texture creation fail, glError " + glError + " retry id " + numTextureFails);
-                    ++numTextureFails;
-                    textureFail = true;
-                    handleLowMemory();
-                    // TODO: Retry logic
-                    numTextureFails = 3;
-                }
-            } while (textureFail && numTextureFails < 3);
+            // Upload the bitmap to a new texture.
+            gl.glGenTextures(1, textureId, 0);
+            gl.glBindTexture(GL11.GL_TEXTURE_2D, textureId[0]);
+            gl.glTexParameteriv(GL11.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES, cropRect, 0);
+            gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP_TO_EDGE);
+            gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP_TO_EDGE);
+            gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
+            gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
+            GLUtils.texImage2D(GL11.GL_TEXTURE_2D, 0, bitmap, 0);
+            glError = gl.glGetError();
+            
             bitmap.recycle();
-
-            // Update texture state.
-            texture.mBitmap = null;
-            texture.mId = textureId[0];
-            texture.mState = Texture.STATE_LOADED;
-
-            // Add to the active list.
-            final TextureReference textureRef = new TextureReference(texture, gl, mUnreferencedTextureQueue, textureId[0]);
-            mActiveTextureList.add(textureRef.activeListEntry);
-            requestRender();
+            if (glError == GL11.GL_OUT_OF_MEMORY) {
+                handleLowMemory();
+            }
+            if (glError != GL11.GL_NO_ERROR) {
+                // There was an error, we need to retry this texture at some later time
+                Log.i(TAG, "Texture creation fail, glError " + glError);
+                texture.mId = 0;
+                texture.mBitmap = null;
+                texture.mState = Texture.STATE_UNLOADED;
+            } else {
+                // Update texture state.
+                texture.mBitmap = null;
+                texture.mId = textureId[0];
+                texture.mState = Texture.STATE_LOADED;
+
+                // Add to the active list.
+                final TextureReference textureRef = new TextureReference(texture, gl, mUnreferencedTextureQueue, textureId[0]);
+                mActiveTextureList.add(textureRef.activeListEntry);
+                requestRender();
+            }
         } else {
             texture.mState = Texture.STATE_ERROR;
         }
@@ -551,9 +562,9 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
         boolean wasLoadingExpensiveTextures = isLoadingExpensiveTextures();
         boolean loadingExpensiveTextures = false;
-        int numTextureThreads = mTextureLoadThreads.length;
+        int numTextureThreads = sTextureLoadThreads.length;
         for (int i = 2; i < numTextureThreads; ++i) {
-            if (mTextureLoadThreads[i].mIsLoading) {
+            if (sTextureLoadThreads[i].mIsLoading) {
                 loadingExpensiveTextures = true;
                 break;
             }
@@ -566,7 +577,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         processTextures(false);
 
         // Update the current time and frame time interval.
-        final long now = SystemClock.uptimeMillis();
+        long now = SystemClock.uptimeMillis();
         final float dt = 0.001f * Math.min(50, now - mFrameTime);
         mFrameInterval = dt;
         mFrameTime = now;
@@ -575,7 +586,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         processCurrentEvent();
         processTouchEvent();
         // Run the update pass.
-        final Lists lists = mLists;
+        final Lists lists = sLists;
         synchronized (lists) {
             final ArrayList<Layer> updateList = lists.updateList;
             boolean isDirty = false;
@@ -586,7 +597,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
             if (isDirty) {
                 requestRender();
             }
-
+        
             // Clear the depth buffer.
             gl.glClear(GL11.GL_DEPTH_BUFFER_BIT);
             gl.glEnable(GL11.GL_SCISSOR_TEST);
@@ -601,7 +612,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
                     layer.renderOpaque(this, gl);
                 }
             }
-
+            
             // Run the blended pass.
             gl.glEnable(GL11.GL_BLEND);
             final ArrayList<Layer> blendedList = lists.blendedList;
@@ -611,10 +622,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
                     layer.renderBlended(this, gl);
                 }
             }
-        }
-        int priority = Process.getThreadPriority(Process.myTid());
-        if (priority != Process.THREAD_PRIORITY_URGENT_DISPLAY) {
-            Log.e(TAG, "The display thread should never be lowered to priority level " + priority);
+            gl.glDisable(GL11.GL_BLEND);
         }
     }
 
@@ -638,6 +646,8 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
     private void processTouchEvent() {
         MotionEvent event = null;
+        int numEvents = mTouchEventQueue.size();
+        int i = 0;
         do {
             // We look at the touch event queue and process one event at a time
             synchronized (mTouchEventQueue) {
@@ -666,7 +676,8 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
                 mTouchEventTarget = null;
             }
             event.recycle();
-        } while (event != null);
+            ++i;
+        } while (event != null && i < numEvents);
         synchronized (this) {
             this.notify();
         }
@@ -697,7 +708,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     }
 
     private Layer hitTest(float x, float y) {
-        final ArrayList<Layer> hitTestList = mLists.hitTestList;
+        final ArrayList<Layer> hitTestList = sLists.hitTestList;
         for (int i = hitTestList.size() - 1; i >= 0; --i) {
             final Layer layer = hitTestList.get(i);
             if (layer != null && !layer.mHidden) {
@@ -714,9 +725,9 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
     private void updateLists() {
         if (mRootLayer != null) {
-            synchronized (mLists) {
-                mLists.clear();
-                mRootLayer.generate(this, mLists);
+            synchronized (sLists) {
+                sLists.clear();
+                mRootLayer.generate(this, sLists);
             }
         }
     }
@@ -759,7 +770,6 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         // Clear the resource texture cache.
         clearCache();
 
-        // Log.i(TAG, "Surface Created for " + this);
         GL11 gl = (GL11) gl1;
         if (mGL == null) {
             mGL = gl;
@@ -770,14 +780,14 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         }
         setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
         // Increase the priority of the render thread.
-        Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);
+        Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
 
         // Disable unused state.
         gl.glEnable(GL11.GL_DITHER);
         gl.glDisable(GL11.GL_LIGHTING);
 
         // Set global state.
-        gl.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
+        // gl.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
 
         // Enable textures.
         gl.glEnable(GL11.GL_TEXTURE_2D);
@@ -821,8 +831,8 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
         if (mRootLayer != null) {
             mRootLayer.onSurfaceCreated(this, gl);
         }
-        synchronized (mLists) {
-            ArrayList<Layer> systemList = mLists.systemList;
+        synchronized (sLists) {
+            ArrayList<Layer> systemList = sLists.systemList;
             for (int i = systemList.size() - 1; i >= 0; --i) {
                 systemList.get(i).onSurfaceCreated(this, gl);
             }
@@ -915,19 +925,16 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         super.surfaceDestroyed(holder);
-        // Log.i(TAG, "Surface destroyed for " + this);
     }
 
     @Override
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
-        // Log.i(TAG, "Attaching to window for " + this);
     }
 
     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
-        // Log.i(TAG, "Detaching from Window for " + this);
     }
 
     private final class TextureLoadThread extends Thread {
@@ -935,14 +942,12 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
 
         public TextureLoadThread() {
             super("TextureLoad");
-            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
         }
 
         public void run() {
-            RenderView view = RenderView.this;
-            Deque<Texture> inputQueue = (mCachedTextureLoadThread == this) ? view.mLoadInputQueueCached : view.mLoadInputQueue;
-            inputQueue = (mVideoTextureLoadThread == this) ? view.mLoadInputQueueVideo : view.mLoadInputQueue;
-            Deque<Texture> outputQueue = view.mLoadOutputQueue;
+            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+            Deque<Texture> inputQueue = (sVideoTextureLoadThread == this) ? sLoadInputQueueVideo : ((sCachedTextureLoadThread == this) ? sLoadInputQueueCached : sLoadInputQueue);
+            Deque<Texture> outputQueue = sLoadOutputQueue;
             try {
                 for (;;) {
                     // Pop the next texture from the input queue.
@@ -952,7 +957,7 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
                             inputQueue.wait();
                         }
                     }
-                    if (mCachedTextureLoadThread != this)
+                    if (sCachedTextureLoadThread != this)
                         mIsLoading = true;
                     // Load the texture bitmap.
                     load(texture);
@@ -977,14 +982,9 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     }
 
     public void shutdown() {
-        // stop all the threads
-        for (int i = 0; i < NUM_TEXTURE_LOAD_THREADS; ++i) {
-            mTextureLoadThreads[i].interrupt();
-        }
-        ArrayUtils.clear(mTextureLoadThreads);
         mRootLayer = null;
-        synchronized (mLists) {
-            mLists.clear();
+        synchronized (sLists) {
+            sLists.clear();
         }
     }
 
@@ -996,6 +996,6 @@ public final class RenderView extends GLSurfaceView implements GLSurfaceView.Ren
     }
 
     public Lists getLists() {
-        return mLists;
+        return sLists;
     }
 }

--- a/src/com/cooliris/media/ReverseGeocoder.java
+++ b/src/com/cooliris/media/ReverseGeocoder.java
@@ -20,25 +20,21 @@ public final class ReverseGeocoder extends Thread {
     // If two points are within 50 miles of each other, use "Around Palo Alto, CA" or "Around Mountain View, CA".
     // instead of directly jumping to the next level and saying "California, US".
     private static final int MAX_LOCALITY_MILE_RANGE = 50;
-
+    private static final Deque<MediaSet> sQueue = new Deque<MediaSet>();
+    private static final DiskCache sGeoCache = new DiskCache("geocoder-cache");
     private static final String TAG = "ReverseGeocoder";
 
-    private final Geocoder mGeocoder;
+    private Geocoder mGeocoder;
     private final Context mContext;
-    private final Deque<MediaSet> mQueue = new Deque<MediaSet>();
-    private final DiskCache mGeoCache = new DiskCache("geocoder-cache");
 
     public ReverseGeocoder(Context context) {
         super(TAG);
         mContext = context;
-        mGeocoder = new Geocoder(mContext);
-        // Loading the addresses in the GeoCache.
-        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
         start();
     }
 
     public void enqueue(MediaSet set) {
-        Deque<MediaSet> inQueue = mQueue;
+        Deque<MediaSet> inQueue = sQueue;
         synchronized (inQueue) {
             inQueue.addLast(set);
             inQueue.notify();
@@ -47,7 +43,10 @@ public final class ReverseGeocoder extends Thread {
 
     @Override
     public void run() {
-        Deque<MediaSet> queue = mQueue;
+        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+        Deque<MediaSet> queue = sQueue;
+        mGeocoder = new Geocoder(mContext);
+        queue.clear();
         try {
             for (;;) {
                 // Wait for the next request.
@@ -66,12 +65,11 @@ public final class ReverseGeocoder extends Thread {
     }
 
     public void flushCache() {
-        mGeoCache.flush();
+        sGeoCache.flush();
     }
 
     public void shutdown() {
         flushCache();
-        mGeoCache.close();
         this.interrupt();
     }
 
@@ -134,8 +132,8 @@ public final class ReverseGeocoder extends Thread {
         }
 
         // Just choose one of the localities if within a 50 mile radius.
-        int distance = (int) LocationMediaFilter.toMile(
-                LocationMediaFilter.distanceBetween(setMinLatitude, setMinLongitude, setMaxLatitude, setMaxLongitude));
+        int distance = (int) LocationMediaFilter.toMile(LocationMediaFilter.distanceBetween(setMinLatitude, setMinLongitude,
+                setMaxLatitude, setMaxLongitude));
         if (distance < MAX_LOCALITY_MILE_RANGE) {
             // Try each of the points and just return the first one to have a valid address.
             Address minLatAddress = lookupAddress(setMinLatitude, set.mMinLatLongitude);
@@ -207,11 +205,11 @@ public final class ReverseGeocoder extends Thread {
                     }
                 }
             }
-    
+
             if (numDetails == desiredNumDetails) {
                 return location;
             }
-    
+
             String locality = addr.getLocality();
             if (locality != null && !("null".equals(locality))) {
                 if (location != null && location.length() > 0) {
@@ -221,11 +219,11 @@ public final class ReverseGeocoder extends Thread {
                 }
                 numDetails++;
             }
-    
+
             if (numDetails == desiredNumDetails) {
                 return location;
             }
-    
+
             String adminArea = addr.getAdminArea();
             if (adminArea != null && !("null".equals(adminArea))) {
                 if (location != null && location.length() > 0) {
@@ -274,7 +272,7 @@ public final class ReverseGeocoder extends Thread {
     private Address lookupAddress(final double latitude, final double longitude) {
         try {
             long locationKey = (long) (((latitude + LocationMediaFilter.LAT_MAX) * 2 * LocationMediaFilter.LAT_MAX + (longitude + LocationMediaFilter.LON_MAX)) * LocationMediaFilter.EARTH_RADIUS_METERS);
-            byte[] cachedLocation = mGeoCache.get(locationKey, 0);
+            byte[] cachedLocation = sGeoCache.get(locationKey, 0);
             Address address = null;
             if (cachedLocation == null || cachedLocation.length == 0) {
                 List<Address> addresses = mGeocoder.getFromLocation(latitude, longitude, 1);
@@ -305,7 +303,7 @@ public final class ReverseGeocoder extends Thread {
                     Utils.writeUTF(dos, address.getUrl());
 
                     dos.flush();
-                    mGeoCache.put(locationKey, bos.toByteArray());
+                    sGeoCache.put(locationKey, bos.toByteArray());
                     dos.close();
                 }
             } else {
@@ -325,7 +323,7 @@ public final class ReverseGeocoder extends Thread {
                     }
                 }
                 if (!locale.getLanguage().equals(Locale.getDefault().getLanguage())) {
-                    mGeoCache.delete(locationKey);
+                    sGeoCache.delete(locationKey);
                     dis.close();
                     return lookupAddress(latitude, longitude);
                 }

--- a/src/com/cooliris/media/TimeBar.java
+++ b/src/com/cooliris/media/TimeBar.java
@@ -25,7 +25,6 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
     private static final int MARKER_SPACING_PIXELS = 50;
     private static final float AUTO_SCROLL_MARGIN = 100f;
     private static final Paint SRC_PAINT = new Paint();
-    private final Context mContext;
     private Listener mListener = null;
     private MediaFeed mFeed = null;
     private float mTotalWidth = 0f;
@@ -44,7 +43,7 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
     private final StringTexture.Config mMonthYearFormat = new StringTexture.Config();
     private final StringTexture.Config mDayFormat = new StringTexture.Config();
     private final SparseArray<StringTexture> mYearLabels = new SparseArray<StringTexture>();
-    private final StringTexture mDateUnknown;
+    private StringTexture mDateUnknown;
     private final StringTexture[] mMonthLabels = new StringTexture[12];
     private final StringTexture[] mDayLabels = new StringTexture[32];
     private final StringTexture[] mOpaqueDayLabels = new StringTexture[32];
@@ -63,18 +62,22 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
     }
 
     TimeBar(Context context) {
-        // Save the context.
-        mContext = context;
-
         // Setup formatting for text labels.
         mMonthYearFormat.fontSize = 17f * Gallery.PIXEL_DENSITY;
         mMonthYearFormat.bold = true;
         mMonthYearFormat.a = 0.85f;
         mDayFormat.fontSize = 17f * Gallery.PIXEL_DENSITY;
         mDayFormat.a = 0.61f;
-
+        regenerateStringsForContext(context);
+        Bitmap background = BitmapFactory.decodeResource(context.getResources(), R.drawable.popup);
+        mBackground = new NinePatch(background, background.getNinePatchChunk(), null);
+        mBackgroundRect = new Rect();
+        SRC_PAINT.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
+    }
+    
+    public void regenerateStringsForContext(Context context) {
         // Create textures for month names.
-        String[] months = mContext.getResources().getStringArray(R.array.months_abbreviated);
+        String[] months = context.getResources().getStringArray(R.array.months_abbreviated);
         for (int i = 0; i < months.length; ++i) {
             mMonthLabels[i] = new StringTexture(months[i], mMonthYearFormat);
         }
@@ -84,10 +87,6 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
             mOpaqueDayLabels[i] = new StringTexture(Integer.toString(i), mMonthYearFormat);
         }
         mDateUnknown = new StringTexture(context.getResources().getString(R.string.date_unknown), mMonthYearFormat);
-        Bitmap background = BitmapFactory.decodeResource(context.getResources(), R.drawable.popup);
-        mBackground = new NinePatch(background, background.getNinePatchChunk(), null);
-        mBackgroundRect = new Rect();
-        SRC_PAINT.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
     }
 
     public void setListener(Listener listener) {
@@ -109,30 +108,6 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
         mScroll = getScrollForPosition(mPosition);
     }
 
-    // public long getTime() {
-    // final float x = mPosition * mTotalWidth;
-    // for (int i = 0, size = mMarkers.size(); i < size; ++i) {
-    // Marker marker = mMarkers.get(i);
-    // if (x <= marker.x) {
-    // return marker.time;
-    // }
-    // }
-    // return 0;
-    // }
-    //
-    // public void setTime(long time) {
-    // synchronized (mMarkers) {
-    // for (int i = 0, size = mMarkers.size(); i < size; ++i) {
-    // Marker marker = mMarkers.get(i);
-    // if (time <= marker.time) {
-    // mPosition = Math.max(0.0f, Math.min(1.0f, marker.x / mTotalWidth));
-    // mScroll = getScrollForPosition(mPosition);
-    // break;
-    // }
-    // }
-    // }
-    // }
-
     public MediaItem getItem() {
         synchronized (mMarkers) {
             // x is between 0 and 1.0f
@@ -257,18 +232,18 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
                         if (month != lastMonth) {
                             lastMonth = month;
                             lastDayBlock = -1;
-                            marker = new Marker(mMonthLabels[month], dx, time.getTimeInMillis(), year, month, dayBlock,
+                            marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock,
                                     Marker.TYPE_MONTH, increment);
                             dx = addMarker(marker);
                         } else if (dayBlock != lastDayBlock) {
                             lastDayBlock = dayBlock;
                             if (dayBlock != 0) {
-                                marker = new Marker(mDayLabels[dayBlock], dx, time.getTimeInMillis(), year, month, dayBlock,
+                                marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock,
                                         Marker.TYPE_DAY, increment);
                                 dx = addMarker(marker);
                             }
                         } else {
-                            marker = new Marker(mDot, dx, time.getTimeInMillis(), year, month, dayBlock, Marker.TYPE_DOT, increment);
+                            marker = new Marker(dx, time.getTimeInMillis(), year, month, dayBlock, Marker.TYPE_DOT, increment);
                             dx = addMarker(marker);
                         }
                         for (int k = 0; k < increment; ++k) {
@@ -496,7 +471,7 @@ public final class TimeBar extends Layer implements MediaFeed.Listener {
     }
 
     private static final class Marker {
-        Marker(StringTexture texture, float x, long time, int year, int month, int day, int type, int expectedCapacity) {
+        Marker(float x, long time, int year, int month, int day, int type, int expectedCapacity) {
             this.x = x;
             this.year = year;
             this.month = month;

--- a/src/com/cooliris/media/UriTexture.java
+++ b/src/com/cooliris/media/UriTexture.java
@@ -85,7 +85,7 @@ public class UriTexture extends Texture {
         final BitmapFactory.Options options = new BitmapFactory.Options();
         options.inScaled = false;
         options.inPreferredConfig = Bitmap.Config.RGB_565;
-        options.inDither = true;
+        options.inDither = false;
         long crc64 = 0;
         Bitmap bitmap = null;
         if (uri.startsWith(ContentResolver.SCHEME_CONTENT)) {
@@ -121,7 +121,7 @@ public class UriTexture extends Texture {
             int ratio = Math.max(ratioX, ratioY);
             ratio = Shared.nextPowerOf2(ratio);
             sampleSize = ratio;
-            options.inDither = true;
+            options.inDither = false;
             options.inJustDecodeBounds = false;
             options.inSampleSize = ratio;
             Thread timeoutThread = new Thread("BitmapTimeoutThread") {
@@ -207,7 +207,7 @@ public class UriTexture extends Texture {
         final BitmapFactory.Options options = new BitmapFactory.Options();
         options.inScaled = false;
         options.inPreferredConfig = Bitmap.Config.RGB_565;
-        options.inDither = true;
+        options.inDither = false;
         if (crc64 != 0) {
             file = createFilePathFromCrc64(crc64, maxResolution);
             try {
@@ -227,7 +227,7 @@ public class UriTexture extends Texture {
             final BitmapFactory.Options options = new BitmapFactory.Options();
             options.inScaled = false;
             options.inPreferredConfig = Bitmap.Config.RGB_565;
-            options.inDither = true;
+            options.inDither = false;
             if (crc64 != 0) {
                 file = createFilePathFromCrc64(crc64, maxResolution);
                 bitmap = BitmapFactory.decodeFile(file, options);

--- a/src/com/cooliris/picasa/PicasaApi.java
+++ b/src/com/cooliris/picasa/PicasaApi.java
@@ -15,7 +15,6 @@ import android.content.Context;
 import android.content.SyncResult;
 import android.net.Uri;
 import android.os.Bundle;
-import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.Xml;
 
@@ -30,11 +29,9 @@ public final class PicasaApi {
 
     static {
         // Build the base query string using screen dimensions.
-        DisplayMetrics metrics = new DisplayMetrics();
-        int maxDimension = Math.max(metrics.widthPixels, metrics.heightPixels);
-        StringBuilder query = new StringBuilder("?imgmax=1024&max-results=1000&thumbsize=");
-        String thumbnailSize = metrics.density <= 1 ? "144u," : "144u,";
-        String screennailSize = maxDimension <= 512 ? "512u" : "800u";
+        final StringBuilder query = new StringBuilder("?imgmax=1024&max-results=1000&thumbsize=");
+        final String thumbnailSize = "144u,";
+        final String screennailSize = "1024u";
         query.append(thumbnailSize);
         query.append(screennailSize);
         BASE_QUERY_STRING = query.toString() + "&visibility=visible";

--- /dev/null
+++ b/src/com/cooliris/wallpaper/RandomDataSource.java
@@ -0,0 +1,43 @@
+package com.cooliris.wallpaper;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+
+import com.cooliris.cache.CacheService;
+import com.cooliris.cache.ImageList;
+import com.cooliris.media.UriTexture;
+import com.cooliris.media.Util;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+public class RandomDataSource implements Slideshow.DataSource {
+    
+    public Bitmap getBitmapForIndex(Context context, int currentSlideshowCounter) {
+        ImageList list = CacheService.getImageList(context);
+        // Once we have the id and the thumbid, we can return a bitmap
+        // First we select a random numbers
+        if (list.ids == null)
+            return null;
+        double random = Math.random();
+        random *= list.ids.length;
+        int index = (int) random;
+        long cacheId = list.thumbids[index];
+        final String uri = CacheService.BASE_CONTENT_STRING_IMAGES + list.ids[index];
+        Bitmap retVal = null;
+        try {
+            retVal = UriTexture.createFromUri(context, uri, UriTexture.MAX_RESOLUTION, UriTexture.MAX_RESOLUTION, cacheId, null);
+            if (retVal != null) {
+                retVal = Util.rotate(retVal, list.orientation[index]);
+            }
+        } catch (OutOfMemoryError e) {
+            ;
+        } catch (IOException e) {
+            ;
+        } catch (URISyntaxException e) {
+            ;
+        }
+        return retVal;
+    }
+
+}

--- /dev/null
+++ b/src/com/cooliris/wallpaper/Slideshow.java
@@ -0,0 +1,225 @@
+package com.cooliris.wallpaper;
+
+//import android.app.Service;
+import com.cooliris.media.Vector3f;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Handler;
+import android.os.SystemClock;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.graphics.PorterDuff.Mode;
+
+public class Slideshow extends SurfaceView implements SurfaceHolder.Callback {
+    public Slideshow(Context context) {
+        super(context);
+        SurfaceHolder holder = getHolder();
+        holder.addCallback(this);
+    }
+
+    public static final int SLIDESHOW_DURATION = 5000;
+
+    public interface DataSource {
+        /**
+         * 
+         * @param currentSlideshowCounter
+         * @return
+         */
+        Bitmap getBitmapForIndex(Context context, int currentSlideshowCounter);
+    }
+
+    private final Handler mHandler = new Handler();
+    private final Runnable mDrawFrame = new Runnable() {
+        public void run() {
+            drawFrame();
+        }
+    };
+    private static final Paint sPaint = new Paint();
+    static {
+        sPaint.setFilterBitmap(true);
+        sPaint.setDither(true);
+    }
+    private boolean mVisible = true;
+    private DataSource mSource;
+    private int mCurrentSlideshowCounter;
+    private Bitmap mBitmap;
+    private Rect mRect;
+    private RectF mFrameRect;
+    private static final Vector3f sGrow = new Vector3f();
+    private Bitmap mQueuedBitmap;
+    private Rect mQueuedRect;
+    private RectF mQueuedFrameRect;
+    private static final Vector3f sQueuedGrow = new Vector3f();
+    
+    private long mPrevTime;
+    private long mTimeElapsed;
+
+    public void setDataSource(DataSource source) {
+        mSource = source;
+    }
+
+    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+        mHandler.post(mDrawFrame);
+        if (mBitmap != null) {
+            mRect = getRectToFitBitmap(mBitmap.getWidth(), mBitmap.getHeight(), width, height);
+            mFrameRect.right = width;
+            mFrameRect.bottom = height;
+        }
+        if (mQueuedBitmap != null) {
+            mQueuedRect = getRectToFitBitmap(mQueuedBitmap.getWidth(), mQueuedBitmap.getHeight(), width, height);
+            mQueuedFrameRect.right = width;
+            mQueuedFrameRect.bottom = height;
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        // We may need to make calls to super once this is a subclass of WallpaperService.
+        mHandler.post(mDrawFrame);
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+
+    }
+
+    public void drawFrame() {
+        final SurfaceHolder holder = getHolder();
+        Rect frame = holder.getSurfaceFrame();
+        final Paint paint = sPaint;
+        Canvas c = null;
+        try {
+            c = holder.lockCanvas();
+            if (c != null) {
+                long now = SystemClock.uptimeMillis();
+                long delta = now - mPrevTime;
+                if (delta > 50)
+                    delta = 50;
+                mTimeElapsed += delta;
+                mPrevTime = now;
+                performSetup(frame.width(), frame.height());
+                // We draw the source bitmap
+                if (mBitmap != null) {
+                    if (mTimeElapsed > SLIDESHOW_DURATION) {
+                        float alpha = ((float)(mTimeElapsed - SLIDESHOW_DURATION)) / 2000.0f;
+                        paint.setColorFilter(null);
+                        if (alpha < 1.0f) {
+                            //int val = (int)(255 * (1.0f - alpha));
+                            //int srcColor = Color.argb(val, 0, 0, 0);
+                            //PorterDuffColorFilter colorFilter = new PorterDuffColorFilter(srcColor, Mode.SRC_IN);
+                            //paint.setColorFilter(null);
+                        }
+                        c.drawBitmap(mBitmap, mRect, mFrameRect, paint);
+                        if (alpha < 1.0f) {
+                            int val = (int)(255 * alpha);
+                            int srcColor = Color.argb(val, 0, 0, 0);
+                            PorterDuffColorFilter colorFilter = new PorterDuffColorFilter(srcColor, Mode.DST_IN);
+                            paint.setColorFilter(colorFilter);
+                        }
+                        
+                        c.drawBitmap(mQueuedBitmap, mQueuedRect, mQueuedFrameRect, paint);
+                        performUpdate(mQueuedFrameRect, sQueuedGrow, delta);
+                        if (alpha >= 1.0f) {
+                            // We switch the image.
+                            mBitmap.recycle();
+                            mRect = mQueuedRect;
+                            mBitmap = mQueuedBitmap;
+                            mFrameRect =  mQueuedFrameRect;
+                            sGrow.set(sQueuedGrow);
+                            mQueuedBitmap = null;
+                            mQueuedRect = null;
+                            mQueuedFrameRect =  null;
+                            mTimeElapsed = 0;
+                        }
+                    } else {
+                        paint.setColorFilter(null);
+                        c.drawBitmap(mBitmap, mRect, mFrameRect, paint);
+                    }
+                    performUpdate(mFrameRect, sGrow, delta);
+                }
+
+            }
+        } finally {
+            if (c != null)
+                holder.unlockCanvasAndPost(c);
+        }
+        mHandler.removeCallbacks(mDrawFrame);
+        if (mVisible) {
+            mHandler.postDelayed(mDrawFrame, 20);
+        }
+    }
+
+    private void performUpdate(RectF rect, Vector3f grow, long delta) {
+        float timeElapsed = ((float)(delta)) / 1000.0f;
+        float amountToGrowX = timeElapsed * (rect.width() / 30.0f);
+        float amountToGrowY = amountToGrowX * (rect.height() / rect.width());
+        rect.top -= amountToGrowY * grow.x;
+        rect.left -= amountToGrowX * grow.y;
+        
+        rect.bottom += amountToGrowY * (1 - grow.x);
+        rect.right += amountToGrowX * (1 - grow.y);
+    }
+
+    private void performSetup(int viewWidth, int viewHeight) {
+        if (mBitmap == null) {
+            mBitmap = getRandomBitmap();
+            if (mBitmap != null) {
+                mRect = getRectToFitBitmap(mBitmap.getWidth(), mBitmap.getHeight(), viewWidth, viewHeight);
+                mFrameRect = new RectF();
+                mFrameRect.right = viewWidth;
+                mFrameRect.bottom = viewHeight;
+                sGrow.set((float)Math.random(), (float)Math.random(), 0);
+            }
+        }
+        if (mQueuedBitmap == null) {
+            mQueuedBitmap = getRandomBitmap();
+            if (mQueuedBitmap == null) {
+                mQueuedBitmap = mBitmap;
+            }
+            if (mQueuedBitmap != null) {
+                mQueuedRect = getRectToFitBitmap(mQueuedBitmap.getWidth(), mQueuedBitmap.getHeight(), viewWidth, viewHeight);
+                mQueuedFrameRect = new RectF();
+                mQueuedFrameRect.right = viewWidth;
+                mQueuedFrameRect.bottom = viewHeight;
+                sQueuedGrow.set((float)Math.random(), (float)Math.random(), 0);
+            }
+        }
+    }
+
+    private Rect getRectToFitBitmap(int bitmapWidth, int bitmapHeight, int viewWidth, int viewHeight) {
+        Rect rect = new Rect();
+        float viewAspect = (float)viewHeight / viewWidth;
+        float newWidth = bitmapWidth * viewAspect;
+        if (bitmapHeight < newWidth) {
+            // Vertically constrained.
+            newWidth = bitmapHeight / viewAspect;
+            rect.set((int)(bitmapWidth/2 - newWidth/2), 0, (int)(bitmapWidth/2 + newWidth/2), bitmapHeight);
+        } else {
+            // Horizontally constrained
+            float newHeight = bitmapWidth * viewAspect;
+            rect.set(0, (int)(bitmapHeight/2 - newHeight/2), bitmapWidth, (int)(bitmapHeight/2 + newHeight/2));
+        }
+        return rect;
+    }
+
+    private Bitmap getRandomBitmap() {
+        if (mSource != null) {
+            return mSource.getBitmapForIndex(getContext(), mCurrentSlideshowCounter++);
+        }
+        return null;
+    }
+
+    public void onVisibilityChanged(boolean visible) {
+        mVisible = visible;
+        if (!visible) {
+            mHandler.removeCallbacks(mDrawFrame);
+        }
+        drawFrame();
+    }
+
+}