blob: 5b6a1ca8d142f976cb063b51087cef91032e80f6 [file] [log] [blame]
Dmitri Plotnikove8643852010-02-17 10:49:05 -08001/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Dmitri Plotnikov022b62d2011-01-28 12:16:07 -080017package com.android.contacts;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080018
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -080019import com.android.contacts.model.AccountTypeManager;
Daniel Lehmann2f77c852012-03-30 15:25:31 -070020import com.android.contacts.util.BitmapUtil;
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080021import com.android.contacts.util.MemoryUtils;
Daniel Lehmannecfc26c2011-09-12 17:44:35 -070022import com.android.contacts.util.UriUtils;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080023import com.google.android.collect.Lists;
Flavio Lerdad33b18c2011-07-17 22:03:15 +010024import com.google.android.collect.Sets;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080025
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080026import android.content.ComponentCallbacks2;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080027import android.content.ContentResolver;
Dave Santoro84cac442011-08-24 15:23:10 -070028import android.content.ContentUris;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080029import android.content.Context;
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080030import android.content.res.Configuration;
Daniel Lehmann2f77c852012-03-30 15:25:31 -070031import android.content.res.Resources;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080032import android.database.Cursor;
33import android.graphics.Bitmap;
Daniel Lehmann2f77c852012-03-30 15:25:31 -070034import android.graphics.Canvas;
35import android.graphics.Color;
36import android.graphics.Paint;
37import android.graphics.Paint.Style;
Daniel Lehmann7a46cde2012-02-01 17:53:44 -080038import android.graphics.drawable.BitmapDrawable;
Makoto Onuki3d3a15c2011-09-22 10:55:08 -070039import android.graphics.drawable.ColorDrawable;
40import android.graphics.drawable.Drawable;
Daniel Lehmann7a46cde2012-02-01 17:53:44 -080041import android.graphics.drawable.TransitionDrawable;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -070042import android.net.Uri;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080043import android.os.Handler;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -070044import android.os.Handler.Callback;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080045import android.os.HandlerThread;
46import android.os.Message;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -080047import android.provider.ContactsContract;
48import android.provider.ContactsContract.Contacts;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080049import android.provider.ContactsContract.Contacts.Photo;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -070050import android.provider.ContactsContract.Data;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -080051import android.provider.ContactsContract.Directory;
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080052import android.text.TextUtils;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -070053import android.util.Log;
Jesse Wilsonfb231aa2011-02-07 15:15:56 -080054import android.util.LruCache;
Daniel Lehmann2f77c852012-03-30 15:25:31 -070055import android.util.TypedValue;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080056import android.widget.ImageView;
57
Dmitri Plotnikoveb689432010-09-24 10:10:57 -070058import java.io.ByteArrayOutputStream;
59import java.io.InputStream;
Makoto Onuki173f2812011-09-06 14:49:27 -070060import java.lang.ref.Reference;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080061import java.lang.ref.SoftReference;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080062import java.util.Iterator;
Flavio Lerdad33b18c2011-07-17 22:03:15 +010063import java.util.List;
64import java.util.Set;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080065import java.util.concurrent.ConcurrentHashMap;
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080066import java.util.concurrent.atomic.AtomicInteger;
Dmitri Plotnikove8643852010-02-17 10:49:05 -080067
68/**
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -080069 * Asynchronously loads contact photos and maintains a cache of photos.
Dmitri Plotnikove8643852010-02-17 10:49:05 -080070 */
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080071public abstract class ContactPhotoManager implements ComponentCallbacks2 {
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -080072 static final String TAG = "ContactPhotoManager";
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -080073 static final boolean DEBUG = false; // Don't submit with true
Daniel Lehmann2f77c852012-03-30 15:25:31 -070074 static final boolean DEBUG_SIZES = false; // Don't submit with true
75
76 /** Caches 180dip in pixel. This is used to detect whether to show the hires or lores version
77 * of the default avatar */
78 private static int s180DipInPixel = -1;
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -080079
80 public static final String CONTACT_PHOTO_SERVICE = "contactPhotos";
81
Daniel Lehmann2f77c852012-03-30 15:25:31 -070082 /**
83 * Returns the resource id of the default avatar. Tries to find a resource that is bigger
84 * than the given extent (width or height). If extent=-1, a thumbnail avatar is returned
85 */
86 public static int getDefaultAvatarResId(Context context, int extent, boolean darkTheme) {
87 // TODO: Is it worth finding a nicer way to do hires/lores here? In practice, the
88 // default avatar doesn't look too different when stretched
89 if (s180DipInPixel == -1) {
90 Resources r = context.getResources();
91 s180DipInPixel = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 180,
92 r.getDisplayMetrics());
93 }
94
95 final boolean hires = (extent != -1) && (extent > s180DipInPixel);
96 return getDefaultAvatarResId(hires, darkTheme);
97 }
98
Daniel Lehmannecfc26c2011-09-12 17:44:35 -070099 public static int getDefaultAvatarResId(boolean hires, boolean darkTheme) {
100 if (hires && darkTheme) return R.drawable.ic_contact_picture_180_holo_dark;
101 if (hires) return R.drawable.ic_contact_picture_180_holo_light;
102 if (darkTheme) return R.drawable.ic_contact_picture_holo_dark;
103 return R.drawable.ic_contact_picture_holo_light;
104 }
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800105
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700106 public static abstract class DefaultImageProvider {
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700107 /**
108 * Applies the default avatar to the ImageView. Extent is an indicator for the size (width
109 * or height). If darkTheme is set, the avatar is one that looks better on dark background
110 */
111 public abstract void applyDefaultImage(ImageView view, int extent, boolean darkTheme);
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700112 }
113
114 private static class AvatarDefaultImageProvider extends DefaultImageProvider {
115 @Override
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700116 public void applyDefaultImage(ImageView view, int extent, boolean darkTheme) {
117 view.setImageResource(getDefaultAvatarResId(view.getContext(), extent, darkTheme));
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700118 }
119 }
120
121 private static class BlankDefaultImageProvider extends DefaultImageProvider {
122 private static Drawable sDrawable;
123
124 @Override
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700125 public void applyDefaultImage(ImageView view, int extent, boolean darkTheme) {
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700126 if (sDrawable == null) {
127 Context context = view.getContext();
128 sDrawable = new ColorDrawable(context.getResources().getColor(
129 R.color.image_placeholder));
130 }
131 view.setImageDrawable(sDrawable);
132 }
133 }
134
Daniel Lehmann2d73de02012-02-21 19:51:38 -0800135 public static final DefaultImageProvider DEFAULT_AVATAR = new AvatarDefaultImageProvider();
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700136
137 public static final DefaultImageProvider DEFAULT_BLANK = new BlankDefaultImageProvider();
138
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800139 /**
140 * Requests the singleton instance of {@link AccountTypeManager} with data bound from
141 * the available authenticators. This method can safely be called from the UI thread.
142 */
143 public static ContactPhotoManager getInstance(Context context) {
Flavio Lerda82e4a562011-07-08 17:05:31 +0100144 Context applicationContext = context.getApplicationContext();
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800145 ContactPhotoManager service =
Flavio Lerda82e4a562011-07-08 17:05:31 +0100146 (ContactPhotoManager) applicationContext.getSystemService(CONTACT_PHOTO_SERVICE);
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800147 if (service == null) {
Flavio Lerda82e4a562011-07-08 17:05:31 +0100148 service = createContactPhotoManager(applicationContext);
149 Log.e(TAG, "No contact photo service in context: " + applicationContext);
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800150 }
151 return service;
152 }
153
154 public static synchronized ContactPhotoManager createContactPhotoManager(Context context) {
155 return new ContactPhotoManagerImpl(context);
156 }
157
158 /**
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700159 * Load thumbnail image into the supplied image view. If the photo is already cached,
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800160 * it is displayed immediately. Otherwise a request is sent to load the photo
161 * from the database.
162 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700163 public abstract void loadThumbnail(ImageView view, long photoId, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700164 DefaultImageProvider defaultProvider);
165
166 /**
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700167 * Calls {@link #loadThumbnail(ImageView, long, boolean, DefaultImageProvider)} with
Daniel Lehmann2d73de02012-02-21 19:51:38 -0800168 * {@link #DEFAULT_AVATAR}.
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700169 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700170 public final void loadThumbnail(ImageView view, long photoId, boolean darkTheme) {
171 loadThumbnail(view, photoId, darkTheme, DEFAULT_AVATAR);
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700172 }
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800173
174 /**
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700175 * Load photo into the supplied image view. If the photo is already cached,
176 * it is displayed immediately. Otherwise a request is sent to load the photo
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800177 * from the location specified by the URI.
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700178 * @param view The target view
179 * @param photoUri The uri of the photo to load
180 * @param requestedExtent Specifies an approximate Max(width, height) of the targetView.
181 * This is useful if the source image can be a lot bigger that the target, so that the decoding
182 * is done using efficient sampling. If requestedExtent is specified, no sampling of the image
183 * is performed
184 * @param darkTheme Whether the background is dark. This is used for default avatars
185 * @param defaultProvider The provider of default avatars (this is used if photoUri doesn't
186 * refer to an existing image)
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800187 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700188 public abstract void loadPhoto(ImageView view, Uri photoUri, int requestedExtent,
189 boolean darkTheme, DefaultImageProvider defaultProvider);
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700190
191 /**
192 * Calls {@link #loadPhoto(ImageView, Uri, boolean, boolean, DefaultImageProvider)} with
Daniel Lehmann2d73de02012-02-21 19:51:38 -0800193 * {@link #DEFAULT_AVATAR}.
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700194 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700195 public final void loadPhoto(ImageView view, Uri photoUri, int requestedExtent,
196 boolean darkTheme) {
197 loadPhoto(view, photoUri, requestedExtent, darkTheme, DEFAULT_AVATAR);
198 }
199
200 /**
201 * Calls {@link #loadPhoto(ImageView, Uri, boolean, boolean, DefaultImageProvider)} with
202 * {@link #DEFAULT_AVATAR} and with the assumption, that the image is a thumbnail
203 */
204 public final void loadDirectoryPhoto(ImageView view, Uri photoUri, boolean darkTheme) {
205 loadPhoto(view, photoUri, -1, darkTheme, DEFAULT_AVATAR);
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700206 }
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800207
208 /**
Daisuke Miyakawaf5be9ba2011-08-05 09:17:07 -0700209 * Remove photo from the supplied image view. This also cancels current pending load request
210 * inside this photo manager.
211 */
212 public abstract void removePhoto(ImageView view);
213
214 /**
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800215 * Temporarily stops loading photos from the database.
216 */
217 public abstract void pause();
218
219 /**
220 * Resumes loading photos from the database.
221 */
222 public abstract void resume();
223
224 /**
225 * Marks all cached photos for reloading. We can continue using cache but should
226 * also make sure the photos haven't changed in the background and notify the views
227 * if so.
228 */
229 public abstract void refreshCache();
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800230
231 /**
Dave Santoro14d20832011-12-02 18:14:52 -0800232 * Stores the given bitmap directly in the LRU bitmap cache.
233 * @param photoUri The URI of the photo (for future requests).
234 * @param bitmap The bitmap.
235 * @param photoBytes The bytes that were parsed to create the bitmap.
236 */
237 public abstract void cacheBitmap(Uri photoUri, Bitmap bitmap, byte[] photoBytes);
238
239 /**
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800240 * Initiates a background process that over time will fill up cache with
241 * preload photos.
242 */
243 public abstract void preloadPhotosInBackground();
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800244
245 // ComponentCallbacks2
246 @Override
247 public void onConfigurationChanged(Configuration newConfig) {
248 }
249
250 // ComponentCallbacks2
251 @Override
252 public void onLowMemory() {
253 }
254
255 // ComponentCallbacks2
256 @Override
257 public void onTrimMemory(int level) {
258 }
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800259}
260
261class ContactPhotoManagerImpl extends ContactPhotoManager implements Callback {
Dmitri Plotnikov33409852010-02-20 15:02:32 -0800262 private static final String LOADER_THREAD_NAME = "ContactPhotoLoader";
263
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800264 private static final int FADE_TRANSITION_DURATION = 200;
265
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800266 /**
267 * Type of message sent by the UI thread to itself to indicate that some photos
268 * need to be loaded.
269 */
270 private static final int MESSAGE_REQUEST_LOADING = 1;
271
272 /**
273 * Type of message sent by the loader thread to indicate that some photos have
274 * been loaded.
275 */
276 private static final int MESSAGE_PHOTOS_LOADED = 2;
277
278 private static final String[] EMPTY_STRING_ARRAY = new String[0];
279
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800280 private static final String[] COLUMNS = new String[] { Photo._ID, Photo.PHOTO };
Dmitri Plotnikov33409852010-02-20 15:02:32 -0800281
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800282 /**
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800283 * Maintains the state of a particular photo.
284 */
285 private static class BitmapHolder {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800286 final byte[] bytes;
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700287 final int originalSmallerExtent;
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800288
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800289 volatile boolean fresh;
Dmitri Plotnikov37dc7cf2010-12-17 19:25:08 -0800290 Bitmap bitmap;
Makoto Onuki173f2812011-09-06 14:49:27 -0700291 Reference<Bitmap> bitmapRef;
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700292 int decodedSampleSize;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800293
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700294 public BitmapHolder(byte[] bytes, int originalSmallerExtent) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800295 this.bytes = bytes;
296 this.fresh = true;
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700297 this.originalSmallerExtent = originalSmallerExtent;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800298 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800299 }
300
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800301 private final Context mContext;
302
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800303 /**
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800304 * An LRU cache for bitmap holders. The cache contains bytes for photos just
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800305 * as they come from the database. Each holder has a soft reference to the
306 * actual bitmap.
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800307 */
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800308 private final LruCache<Object, BitmapHolder> mBitmapHolderCache;
309
310 /**
Makoto Onuki1f0239e2012-02-27 17:13:47 -0800311 * {@code true} if ALL entries in {@link #mBitmapHolderCache} are NOT fresh.
312 */
313 private volatile boolean mBitmapHolderCacheAllUnfresh = true;
314
315 /**
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800316 * Cache size threshold at which bitmaps will not be preloaded.
317 */
318 private final int mBitmapHolderCacheRedZoneBytes;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800319
320 /**
321 * Level 2 LRU cache for bitmaps. This is a smaller cache that holds
322 * the most recently used bitmaps to save time on decoding
323 * them from bytes (the bytes are stored in {@link #mBitmapHolderCache}.
324 */
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800325 private final LruCache<Object, Bitmap> mBitmapCache;
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800326
327 /**
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700328 * A map from ImageView to the corresponding photo ID or uri, encapsulated in a request.
329 * The request may swapped out before the photo loading request is started.
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800330 */
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700331 private final ConcurrentHashMap<ImageView, Request> mPendingRequests =
332 new ConcurrentHashMap<ImageView, Request>();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800333
334 /**
335 * Handler for messages sent to the UI thread.
336 */
337 private final Handler mMainThreadHandler = new Handler(this);
338
339 /**
340 * Thread responsible for loading photos from the database. Created upon
341 * the first request.
342 */
343 private LoaderThread mLoaderThread;
344
345 /**
346 * A gate to make sure we only send one instance of MESSAGE_PHOTOS_NEEDED at a time.
347 */
348 private boolean mLoadingRequested;
349
350 /**
351 * Flag indicating if the image loading is paused.
352 */
353 private boolean mPaused;
354
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800355 /** Cache size for {@link #mBitmapHolderCache} for devices with "large" RAM. */
356 private static final int HOLDER_CACHE_SIZE = 2000000;
357
358 /** Cache size for {@link #mBitmapCache} for devices with "large" RAM. */
359 private static final int BITMAP_CACHE_SIZE = 36864 * 48; // 1728K
360
361 private static final int LARGE_RAM_THRESHOLD = 640 * 1024 * 1024;
362
363 /** For debug: How many times we had to reload cached photo for a stale entry */
364 private final AtomicInteger mStaleCacheOverwrite = new AtomicInteger();
365
366 /** For debug: How many times we had to reload cached photo for a fresh entry. Should be 0. */
367 private final AtomicInteger mFreshCacheOverwrite = new AtomicInteger();
368
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800369 public ContactPhotoManagerImpl(Context context) {
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800370 mContext = context;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800371
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800372 final float cacheSizeAdjustment =
373 (MemoryUtils.getTotalMemorySize() >= LARGE_RAM_THRESHOLD) ? 1.0f : 0.5f;
374 final int bitmapCacheSize = (int) (cacheSizeAdjustment * BITMAP_CACHE_SIZE);
375 mBitmapCache = new LruCache<Object, Bitmap>(bitmapCacheSize) {
376 @Override protected int sizeOf(Object key, Bitmap value) {
377 return value.getByteCount();
378 }
379
380 @Override protected void entryRemoved(
381 boolean evicted, Object key, Bitmap oldValue, Bitmap newValue) {
382 if (DEBUG) dumpStats();
383 }
384 };
385 final int holderCacheSize = (int) (cacheSizeAdjustment * HOLDER_CACHE_SIZE);
386 mBitmapHolderCache = new LruCache<Object, BitmapHolder>(holderCacheSize) {
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800387 @Override protected int sizeOf(Object key, BitmapHolder value) {
Jesse Wilsonab79a262011-02-09 15:34:31 -0800388 return value.bytes != null ? value.bytes.length : 0;
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800389 }
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800390
391 @Override protected void entryRemoved(
392 boolean evicted, Object key, BitmapHolder oldValue, BitmapHolder newValue) {
393 if (DEBUG) dumpStats();
394 }
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800395 };
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800396 mBitmapHolderCacheRedZoneBytes = (int) (holderCacheSize * 0.75);
397 Log.i(TAG, "Cache adj: " + cacheSizeAdjustment);
398 if (DEBUG) {
399 Log.d(TAG, "Cache size: " + btk(mBitmapHolderCache.maxSize())
400 + " + " + btk(mBitmapCache.maxSize()));
401 }
402 }
403
404 /** Converts bytes to K bytes, rounding up. Used only for debug log. */
405 private static String btk(int bytes) {
406 return ((bytes + 1023) / 1024) + "K";
407 }
408
409 private static final int safeDiv(int dividend, int divisor) {
410 return (divisor == 0) ? 0 : (dividend / divisor);
411 }
412
413 /**
414 * Dump cache stats on logcat.
415 */
416 private void dumpStats() {
417 if (!DEBUG) return;
418 {
419 int numHolders = 0;
420 int rawBytes = 0;
421 int bitmapBytes = 0;
422 int numBitmaps = 0;
423 for (BitmapHolder h : mBitmapHolderCache.snapshot().values()) {
424 numHolders++;
425 if (h.bytes != null) {
426 rawBytes += h.bytes.length;
427 }
428 Bitmap b = h.bitmapRef != null ? h.bitmapRef.get() : null;
429 if (b != null) {
430 numBitmaps++;
431 bitmapBytes += b.getByteCount();
432 }
433 }
434 Log.d(TAG, "L1: " + btk(rawBytes) + " + " + btk(bitmapBytes) + " = "
435 + btk(rawBytes + bitmapBytes) + ", " + numHolders + " holders, "
436 + numBitmaps + " bitmaps, avg: "
437 + btk(safeDiv(rawBytes, numHolders))
438 + "," + btk(safeDiv(bitmapBytes,numBitmaps)));
439 Log.d(TAG, "L1 Stats: " + mBitmapHolderCache.toString()
440 + ", overwrite: fresh=" + mFreshCacheOverwrite.get()
441 + " stale=" + mStaleCacheOverwrite.get());
442 }
443
444 {
445 int numBitmaps = 0;
446 int bitmapBytes = 0;
447 for (Bitmap b : mBitmapCache.snapshot().values()) {
448 numBitmaps++;
449 bitmapBytes += b.getByteCount();
450 }
451 Log.d(TAG, "L2: " + btk(bitmapBytes) + ", " + numBitmaps + " bitmaps"
452 + ", avg: " + btk(safeDiv(bitmapBytes, numBitmaps)));
453 // We don't get from L2 cache, so L2 stats is meaningless.
454 }
455 }
456
457 @Override
458 public void onTrimMemory(int level) {
459 if (DEBUG) Log.d(TAG, "onTrimMemory: " + level);
460 if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
461 // Clear the caches. Note all pending requests will be removed too.
462 clear();
463 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800464 }
465
466 @Override
467 public void preloadPhotosInBackground() {
468 ensureLoaderThread();
469 mLoaderThread.requestPreloading();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800470 }
471
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800472 @Override
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700473 public void loadThumbnail(ImageView view, long photoId, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700474 DefaultImageProvider defaultProvider) {
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800475 if (photoId == 0) {
476 // No photo is needed
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700477 defaultProvider.applyDefaultImage(view, -1, darkTheme);
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800478 mPendingRequests.remove(view);
479 } else {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800480 if (DEBUG) Log.d(TAG, "loadPhoto request: " + photoId);
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700481 loadPhotoByIdOrUri(view, Request.createFromThumbnailId(photoId, darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700482 defaultProvider));
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700483 }
484 }
485
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800486 @Override
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700487 public void loadPhoto(ImageView view, Uri photoUri, int requestedExtent, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700488 DefaultImageProvider defaultProvider) {
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700489 if (photoUri == null) {
490 // No photo is needed
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700491 defaultProvider.applyDefaultImage(view, requestedExtent, darkTheme);
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700492 mPendingRequests.remove(view);
493 } else {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800494 if (DEBUG) Log.d(TAG, "loadPhoto request: " + photoUri);
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700495 loadPhotoByIdOrUri(view, Request.createFromUri(photoUri, requestedExtent, darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700496 defaultProvider));
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700497 }
498 }
499
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700500 private void loadPhotoByIdOrUri(ImageView view, Request request) {
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800501 boolean loaded = loadCachedPhoto(view, request, false);
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700502 if (loaded) {
503 mPendingRequests.remove(view);
504 } else {
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700505 mPendingRequests.put(view, request);
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700506 if (!mPaused) {
507 // Send a request to start loading photos
508 requestLoading();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800509 }
510 }
511 }
512
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800513 @Override
Daisuke Miyakawaf5be9ba2011-08-05 09:17:07 -0700514 public void removePhoto(ImageView view) {
515 view.setImageDrawable(null);
516 mPendingRequests.remove(view);
517 }
518
519 @Override
Dmitri Plotnikov718a2502010-11-23 17:56:28 -0800520 public void refreshCache() {
Makoto Onuki1f0239e2012-02-27 17:13:47 -0800521 if (mBitmapHolderCacheAllUnfresh) {
522 if (DEBUG) Log.d(TAG, "refreshCache -- no fresh entries.");
523 return;
524 }
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800525 if (DEBUG) Log.d(TAG, "refreshCache");
Makoto Onuki1f0239e2012-02-27 17:13:47 -0800526 mBitmapHolderCacheAllUnfresh = true;
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800527 for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800528 holder.fresh = false;
Dmitri Plotnikov718a2502010-11-23 17:56:28 -0800529 }
530 }
531
532 /**
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800533 * Checks if the photo is present in cache. If so, sets the photo on the view.
534 *
535 * @return false if the photo needs to be (re)loaded from the provider.
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800536 */
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800537 private boolean loadCachedPhoto(ImageView view, Request request, boolean fadeIn) {
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700538 BitmapHolder holder = mBitmapHolderCache.get(request.getKey());
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800539 if (holder == null) {
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700540 // The bitmap has not been loaded ==> show default avatar
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700541 request.applyDefaultImage(view);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800542 return false;
543 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800544
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800545 if (holder.bytes == null) {
Makoto Onuki3d3a15c2011-09-22 10:55:08 -0700546 request.applyDefaultImage(view);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800547 return holder.fresh;
548 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800549
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700550 Bitmap cachedBitmap = holder.bitmapRef == null ? null : holder.bitmapRef.get();
551 if (cachedBitmap == null) {
552 if (holder.bytes.length < 8 * 1024) {
553 // Small thumbnails are usually quick to inflate. Let's do that on the UI thread
554 inflateBitmap(holder, request.getRequestedExtent());
555 cachedBitmap = holder.bitmap;
556 if (cachedBitmap == null) return false;
557 } else {
558 // This is bigger data. Let's send that back to the Loader so that we can
559 // inflate this in the background
560 request.applyDefaultImage(view);
561 return false;
562 }
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700563 }
Dmitri Plotnikov718a2502010-11-23 17:56:28 -0800564
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700565 final Drawable previousDrawable = view.getDrawable();
566 if (fadeIn && previousDrawable != null) {
567 final Drawable[] layers = new Drawable[2];
568 // Prevent cascade of TransitionDrawables.
569 if (previousDrawable instanceof TransitionDrawable) {
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700570 final TransitionDrawable previousTransitionDrawable =
571 (TransitionDrawable) previousDrawable;
572 layers[0] = previousTransitionDrawable.getDrawable(
573 previousTransitionDrawable.getNumberOfLayers() - 1);
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700574 } else {
575 layers[0] = previousDrawable;
576 }
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700577 layers[1] = new BitmapDrawable(mContext.getResources(), cachedBitmap);
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800578 TransitionDrawable drawable = new TransitionDrawable(layers);
579 view.setImageDrawable(drawable);
580 drawable.startTransition(FADE_TRANSITION_DURATION);
581 } else {
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700582 view.setImageBitmap(cachedBitmap);
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800583 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800584
Daniel Lehmanne7696de2012-04-06 14:15:06 -0700585 // Put the bitmap in the LRU cache. But only do this for images that are small enough
586 // (we require that at least six of those can be cached at the same time)
587 if (cachedBitmap.getByteCount() < mBitmapCache.maxSize() / 6) {
588 mBitmapCache.put(request.getKey(), cachedBitmap);
589 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800590
591 // Soften the reference
592 holder.bitmap = null;
593
594 return holder.fresh;
595 }
596
597 /**
598 * If necessary, decodes bytes stored in the holder to Bitmap. As long as the
599 * bitmap is held either by {@link #mBitmapCache} or by a soft reference in
600 * the holder, it will not be necessary to decode the bitmap.
601 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700602 private static void inflateBitmap(BitmapHolder holder, int requestedExtent) {
603 final int sampleSize =
604 BitmapUtil.findOptimalSampleSize(holder.originalSmallerExtent, requestedExtent);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800605 byte[] bytes = holder.bytes;
606 if (bytes == null || bytes.length == 0) {
607 return;
608 }
609
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700610 if (sampleSize == holder.decodedSampleSize) {
611 // Check the soft reference. If will be retained if the bitmap is also
612 // in the LRU cache, so we don't need to check the LRU cache explicitly.
613 if (holder.bitmapRef != null) {
614 holder.bitmap = holder.bitmapRef.get();
615 if (holder.bitmap != null) {
616 return;
617 }
Dmitri Plotnikov718a2502010-11-23 17:56:28 -0800618 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800619 }
620
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800621 try {
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700622 Bitmap bitmap = BitmapUtil.decodeBitmapFromBytes(bytes, sampleSize);
623
624 // make bitmap mutable and draw size onto it
625 if (DEBUG_SIZES) {
626 Bitmap original = bitmap;
627 bitmap = bitmap.copy(bitmap.getConfig(), true);
628 original.recycle();
629 Canvas canvas = new Canvas(bitmap);
630 Paint paint = new Paint();
631 paint.setTextSize(16);
632 paint.setColor(Color.BLUE);
633 paint.setStyle(Style.FILL);
634 canvas.drawRect(0.0f, 0.0f, 50.0f, 20.0f, paint);
635 paint.setColor(Color.WHITE);
636 paint.setAntiAlias(true);
637 canvas.drawText(bitmap.getWidth() + "/" + sampleSize, 0, 15, paint);
638 }
639
640 holder.decodedSampleSize = sampleSize;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800641 holder.bitmap = bitmap;
642 holder.bitmapRef = new SoftReference<Bitmap>(bitmap);
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800643 if (DEBUG) {
644 Log.d(TAG, "inflateBitmap " + btk(bytes.length) + " -> "
645 + bitmap.getWidth() + "x" + bitmap.getHeight()
646 + ", " + btk(bitmap.getByteCount()));
647 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800648 } catch (OutOfMemoryError e) {
649 // Do nothing - the photo will appear to be missing
650 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800651 }
652
Dmitri Plotnikovb369c492010-03-24 18:11:24 -0700653 public void clear() {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800654 if (DEBUG) Log.d(TAG, "clear");
Dmitri Plotnikovb369c492010-03-24 18:11:24 -0700655 mPendingRequests.clear();
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800656 mBitmapHolderCache.evictAll();
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800657 mBitmapCache.evictAll();
Dmitri Plotnikovb369c492010-03-24 18:11:24 -0700658 }
659
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800660 @Override
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800661 public void pause() {
662 mPaused = true;
663 }
664
Dmitri Plotnikov34b24ef2011-01-28 13:41:07 -0800665 @Override
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800666 public void resume() {
667 mPaused = false;
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800668 if (DEBUG) dumpStats();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800669 if (!mPendingRequests.isEmpty()) {
670 requestLoading();
671 }
672 }
673
674 /**
675 * Sends a message to this thread itself to start loading images. If the current
676 * view contains multiple image views, all of those image views will get a chance
677 * to request their respective photos before any of those requests are executed.
678 * This allows us to load images in bulk.
679 */
680 private void requestLoading() {
681 if (!mLoadingRequested) {
682 mLoadingRequested = true;
683 mMainThreadHandler.sendEmptyMessage(MESSAGE_REQUEST_LOADING);
684 }
685 }
686
687 /**
688 * Processes requests on the main thread.
689 */
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700690 @Override
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800691 public boolean handleMessage(Message msg) {
692 switch (msg.what) {
693 case MESSAGE_REQUEST_LOADING: {
694 mLoadingRequested = false;
695 if (!mPaused) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800696 ensureLoaderThread();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800697 mLoaderThread.requestLoading();
698 }
699 return true;
700 }
701
702 case MESSAGE_PHOTOS_LOADED: {
703 if (!mPaused) {
704 processLoadedImages();
705 }
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800706 if (DEBUG) dumpStats();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800707 return true;
708 }
709 }
710 return false;
711 }
712
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800713 public void ensureLoaderThread() {
714 if (mLoaderThread == null) {
715 mLoaderThread = new LoaderThread(mContext.getContentResolver());
716 mLoaderThread.start();
717 }
718 }
719
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800720 /**
721 * Goes over pending loading requests and displays loaded photos. If some of the
722 * photos still haven't been loaded, sends another request for image loading.
723 */
724 private void processLoadedImages() {
725 Iterator<ImageView> iterator = mPendingRequests.keySet().iterator();
726 while (iterator.hasNext()) {
727 ImageView view = iterator.next();
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700728 Request key = mPendingRequests.get(view);
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800729 boolean loaded = loadCachedPhoto(view, key, true);
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800730 if (loaded) {
731 iterator.remove();
732 }
733 }
734
Dmitri Plotnikov37dc7cf2010-12-17 19:25:08 -0800735 softenCache();
736
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800737 if (!mPendingRequests.isEmpty()) {
738 requestLoading();
739 }
740 }
741
742 /**
Dmitri Plotnikov37dc7cf2010-12-17 19:25:08 -0800743 * Removes strong references to loaded bitmaps to allow them to be garbage collected
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800744 * if needed. Some of the bitmaps will still be retained by {@link #mBitmapCache}.
Dmitri Plotnikov37dc7cf2010-12-17 19:25:08 -0800745 */
746 private void softenCache() {
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800747 for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
Dmitri Plotnikov37dc7cf2010-12-17 19:25:08 -0800748 holder.bitmap = null;
749 }
750 }
751
752 /**
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800753 * Stores the supplied bitmap in cache.
754 */
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700755 private void cacheBitmap(Object key, byte[] bytes, boolean preloading, int requestedExtent) {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800756 if (DEBUG) {
757 BitmapHolder prev = mBitmapHolderCache.get(key);
758 if (prev != null && prev.bytes != null) {
759 Log.d(TAG, "Overwriting cache: key=" + key + (prev.fresh ? " FRESH" : " stale"));
760 if (prev.fresh) {
761 mFreshCacheOverwrite.incrementAndGet();
762 } else {
763 mStaleCacheOverwrite.incrementAndGet();
764 }
765 }
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700766 Log.d(TAG, "Caching data: key=" + key + ", " +
767 (bytes == null ? "<null>" : btk(bytes.length)));
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -0800768 }
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700769 BitmapHolder holder = new BitmapHolder(bytes,
770 bytes == null ? -1 : BitmapUtil.getSmallerExtentFromBytes(bytes));
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800771
772 // Unless this image is being preloaded, decode it right away while
773 // we are still on the background thread.
774 if (!preloading) {
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700775 inflateBitmap(holder, requestedExtent);
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800776 }
777
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800778 mBitmapHolderCache.put(key, holder);
Makoto Onuki1f0239e2012-02-27 17:13:47 -0800779 mBitmapHolderCacheAllUnfresh = false;
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800780 }
781
Dave Santoro14d20832011-12-02 18:14:52 -0800782 @Override
783 public void cacheBitmap(Uri photoUri, Bitmap bitmap, byte[] photoBytes) {
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700784 final int smallerExtent = Math.min(bitmap.getWidth(), bitmap.getHeight());
785 // We can pretend here that the extent of the photo was the size that we originally
786 // requested
787 Request request = Request.createFromUri(photoUri, smallerExtent, false, DEFAULT_AVATAR);
788 BitmapHolder holder = new BitmapHolder(photoBytes, smallerExtent);
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700789 holder.bitmapRef = new SoftReference<Bitmap>(bitmap);
Dave Santoro14d20832011-12-02 18:14:52 -0800790 mBitmapHolderCache.put(request.getKey(), holder);
Makoto Onuki1f0239e2012-02-27 17:13:47 -0800791 mBitmapHolderCacheAllUnfresh = false;
Daniel Lehmann7a46cde2012-02-01 17:53:44 -0800792 mBitmapCache.put(request.getKey(), bitmap);
Dave Santoro14d20832011-12-02 18:14:52 -0800793 }
794
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800795 /**
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700796 * Populates an array of photo IDs that need to be loaded. Also decodes bitmaps that we have
797 * already loaded
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800798 */
Flavio Lerdad33b18c2011-07-17 22:03:15 +0100799 private void obtainPhotoIdsAndUrisToLoad(Set<Long> photoIds,
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700800 Set<String> photoIdsAsStrings, Set<Request> uris) {
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800801 photoIds.clear();
Dmitri Plotnikov33409852010-02-20 15:02:32 -0800802 photoIdsAsStrings.clear();
Dmitri Plotnikov0f7462c2010-10-20 14:41:18 -0700803 uris.clear();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800804
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700805 boolean jpegsDecoded = false;
806
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800807 /*
808 * Since the call is made from the loader thread, the map could be
809 * changing during the iteration. That's not really a problem:
810 * ConcurrentHashMap will allow those changes to happen without throwing
811 * exceptions. Since we may miss some requests in the situation of
812 * concurrent change, we will need to check the map again once loading
813 * is complete.
814 */
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700815 Iterator<Request> iterator = mPendingRequests.values().iterator();
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800816 while (iterator.hasNext()) {
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700817 Request request = iterator.next();
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700818 final BitmapHolder holder = mBitmapHolderCache.get(request.getKey());
819 if (holder != null && holder.bytes != null && holder.fresh &&
820 (holder.bitmapRef == null || holder.bitmapRef.get() == null)) {
821 // This was previously loaded but we don't currently have the inflated Bitmap
822 inflateBitmap(holder, request.getRequestedExtent());
823 jpegsDecoded = true;
824 } else {
825 if (holder == null || !holder.fresh) {
826 if (request.isUriRequest()) {
827 uris.add(request);
828 } else {
829 photoIds.add(request.getId());
830 photoIdsAsStrings.add(String.valueOf(request.mId));
831 }
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700832 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800833 }
834 }
Daniel Lehmannf8494db2012-04-02 12:51:31 -0700835
836 if (jpegsDecoded) mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800837 }
838
839 /**
840 * The thread that performs loading of photos from the database.
841 */
842 private class LoaderThread extends HandlerThread implements Callback {
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700843 private static final int BUFFER_SIZE = 1024*16;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800844 private static final int MESSAGE_PRELOAD_PHOTOS = 0;
845 private static final int MESSAGE_LOAD_PHOTOS = 1;
846
847 /**
848 * A pause between preload batches that yields to the UI thread.
849 */
Makoto Onuki173f2812011-09-06 14:49:27 -0700850 private static final int PHOTO_PRELOAD_DELAY = 1000;
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800851
852 /**
853 * Number of photos to preload per batch.
854 */
855 private static final int PRELOAD_BATCH = 25;
856
857 /**
858 * Maximum number of photos to preload. If the cache size is 2Mb and
859 * the expected average size of a photo is 4kb, then this number should be 2Mb/4kb = 500.
860 */
Makoto Onuki173f2812011-09-06 14:49:27 -0700861 private static final int MAX_PHOTOS_TO_PRELOAD = 100;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700862
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800863 private final ContentResolver mResolver;
864 private final StringBuilder mStringBuilder = new StringBuilder();
Flavio Lerdad33b18c2011-07-17 22:03:15 +0100865 private final Set<Long> mPhotoIds = Sets.newHashSet();
866 private final Set<String> mPhotoIdsAsStrings = Sets.newHashSet();
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700867 private final Set<Request> mPhotoUris = Sets.newHashSet();
Flavio Lerdad33b18c2011-07-17 22:03:15 +0100868 private final List<Long> mPreloadPhotoIds = Lists.newArrayList();
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800869
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800870 private Handler mLoaderThreadHandler;
Dmitri Plotnikoveb689432010-09-24 10:10:57 -0700871 private byte mBuffer[];
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800872
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800873 private static final int PRELOAD_STATUS_NOT_STARTED = 0;
874 private static final int PRELOAD_STATUS_IN_PROGRESS = 1;
875 private static final int PRELOAD_STATUS_DONE = 2;
876
877 private int mPreloadStatus = PRELOAD_STATUS_NOT_STARTED;
878
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800879 public LoaderThread(ContentResolver resolver) {
880 super(LOADER_THREAD_NAME);
881 mResolver = resolver;
882 }
883
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800884 public void ensureHandler() {
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800885 if (mLoaderThreadHandler == null) {
886 mLoaderThreadHandler = new Handler(getLooper(), this);
887 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800888 }
889
890 /**
891 * Kicks off preloading of the next batch of photos on the background thread.
892 * Preloading will happen after a delay: we want to yield to the UI thread
893 * as much as possible.
894 * <p>
895 * If preloading is already complete, does nothing.
896 */
897 public void requestPreloading() {
898 if (mPreloadStatus == PRELOAD_STATUS_DONE) {
899 return;
900 }
901
902 ensureHandler();
903 if (mLoaderThreadHandler.hasMessages(MESSAGE_LOAD_PHOTOS)) {
904 return;
905 }
906
907 mLoaderThreadHandler.sendEmptyMessageDelayed(
908 MESSAGE_PRELOAD_PHOTOS, PHOTO_PRELOAD_DELAY);
909 }
910
911 /**
912 * Sends a message to this thread to load requested photos. Cancels a preloading
913 * request, if any: we don't want preloading to impede loading of the photos
914 * we need to display now.
915 */
916 public void requestLoading() {
917 ensureHandler();
918 mLoaderThreadHandler.removeMessages(MESSAGE_PRELOAD_PHOTOS);
919 mLoaderThreadHandler.sendEmptyMessage(MESSAGE_LOAD_PHOTOS);
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800920 }
921
922 /**
923 * Receives the above message, loads photos and then sends a message
924 * to the main thread to process them.
925 */
Daniel Lehmannecfc26c2011-09-12 17:44:35 -0700926 @Override
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800927 public boolean handleMessage(Message msg) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800928 switch (msg.what) {
929 case MESSAGE_PRELOAD_PHOTOS:
930 preloadPhotosInBackground();
931 break;
932 case MESSAGE_LOAD_PHOTOS:
933 loadPhotosInBackground();
934 break;
935 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800936 return true;
937 }
938
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800939 /**
940 * The first time it is called, figures out which photos need to be preloaded.
941 * Each subsequent call preloads the next batch of photos and requests
942 * another cycle of preloading after a delay. The whole process ends when
943 * we either run out of photos to preload or fill up cache.
944 */
945 private void preloadPhotosInBackground() {
946 if (mPreloadStatus == PRELOAD_STATUS_DONE) {
947 return;
Dmitri Plotnikove8643852010-02-17 10:49:05 -0800948 }
Dmitri Plotnikov33409852010-02-20 15:02:32 -0800949
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800950 if (mPreloadStatus == PRELOAD_STATUS_NOT_STARTED) {
951 queryPhotosForPreload();
952 if (mPreloadPhotoIds.isEmpty()) {
953 mPreloadStatus = PRELOAD_STATUS_DONE;
954 } else {
955 mPreloadStatus = PRELOAD_STATUS_IN_PROGRESS;
956 }
957 requestPreloading();
958 return;
959 }
960
Jesse Wilsonfb231aa2011-02-07 15:15:56 -0800961 if (mBitmapHolderCache.size() > mBitmapHolderCacheRedZoneBytes) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800962 mPreloadStatus = PRELOAD_STATUS_DONE;
963 return;
964 }
965
966 mPhotoIds.clear();
967 mPhotoIdsAsStrings.clear();
968
969 int count = 0;
970 int preloadSize = mPreloadPhotoIds.size();
971 while(preloadSize > 0 && mPhotoIds.size() < PRELOAD_BATCH) {
972 preloadSize--;
973 count++;
974 Long photoId = mPreloadPhotoIds.get(preloadSize);
975 mPhotoIds.add(photoId);
976 mPhotoIdsAsStrings.add(photoId.toString());
977 mPreloadPhotoIds.remove(preloadSize);
978 }
979
Daniel Lehmann2f77c852012-03-30 15:25:31 -0700980 loadThumbnails(true);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800981
982 if (preloadSize == 0) {
983 mPreloadStatus = PRELOAD_STATUS_DONE;
984 }
985
Makoto Onuki173f2812011-09-06 14:49:27 -0700986 Log.v(TAG, "Preloaded " + count + " photos. Cached bytes: "
987 + mBitmapHolderCache.size());
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800988
989 requestPreloading();
990 }
991
992 private void queryPhotosForPreload() {
993 Cursor cursor = null;
994 try {
995 Uri uri = Contacts.CONTENT_URI.buildUpon().appendQueryParameter(
996 ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(Directory.DEFAULT))
Daniel Lehmann4ccae562011-05-02 16:39:01 -0700997 .appendQueryParameter(ContactsContract.LIMIT_PARAM_KEY,
998 String.valueOf(MAX_PHOTOS_TO_PRELOAD))
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -0800999 .build();
1000 cursor = mResolver.query(uri, new String[] { Contacts.PHOTO_ID },
1001 Contacts.PHOTO_ID + " NOT NULL AND " + Contacts.PHOTO_ID + "!=0",
1002 null,
Daniel Lehmann4ccae562011-05-02 16:39:01 -07001003 Contacts.STARRED + " DESC, " + Contacts.LAST_TIME_CONTACTED + " DESC");
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001004
1005 if (cursor != null) {
1006 while (cursor.moveToNext()) {
1007 // Insert them in reverse order, because we will be taking
1008 // them from the end of the list for loading.
1009 mPreloadPhotoIds.add(0, cursor.getLong(0));
1010 }
1011 }
1012 } finally {
1013 if (cursor != null) {
1014 cursor.close();
1015 }
1016 }
1017 }
1018
1019 private void loadPhotosInBackground() {
1020 obtainPhotoIdsAndUrisToLoad(mPhotoIds, mPhotoIdsAsStrings, mPhotoUris);
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001021 loadThumbnails(false);
1022 loadUriBasedPhotos();
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001023 requestPreloading();
1024 }
1025
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001026 /** Loads thumbnail photos with ids */
1027 private void loadThumbnails(boolean preloading) {
Flavio Lerdad33b18c2011-07-17 22:03:15 +01001028 if (mPhotoIds.isEmpty()) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001029 return;
1030 }
1031
1032 // Remove loaded photos from the preload queue: we don't want
1033 // the preloading process to load them again.
1034 if (!preloading && mPreloadStatus == PRELOAD_STATUS_IN_PROGRESS) {
Flavio Lerdad33b18c2011-07-17 22:03:15 +01001035 for (Long id : mPhotoIds) {
1036 mPreloadPhotoIds.remove(id);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001037 }
1038 if (mPreloadPhotoIds.isEmpty()) {
1039 mPreloadStatus = PRELOAD_STATUS_DONE;
1040 }
1041 }
1042
1043 mStringBuilder.setLength(0);
1044 mStringBuilder.append(Photo._ID + " IN(");
Flavio Lerdad33b18c2011-07-17 22:03:15 +01001045 for (int i = 0; i < mPhotoIds.size(); i++) {
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001046 if (i != 0) {
1047 mStringBuilder.append(',');
1048 }
1049 mStringBuilder.append('?');
1050 }
1051 mStringBuilder.append(')');
1052
1053 Cursor cursor = null;
1054 try {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -08001055 if (DEBUG) Log.d(TAG, "Loading " + TextUtils.join(",", mPhotoIdsAsStrings));
Dave Santoro84cac442011-08-24 15:23:10 -07001056 cursor = mResolver.query(Data.CONTENT_URI,
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001057 COLUMNS,
1058 mStringBuilder.toString(),
1059 mPhotoIdsAsStrings.toArray(EMPTY_STRING_ARRAY),
1060 null);
1061
1062 if (cursor != null) {
1063 while (cursor.moveToNext()) {
1064 Long id = cursor.getLong(0);
1065 byte[] bytes = cursor.getBlob(1);
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001066 cacheBitmap(id, bytes, preloading, -1);
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001067 mPhotoIds.remove(id);
1068 }
1069 }
1070 } finally {
1071 if (cursor != null) {
1072 cursor.close();
1073 }
1074 }
1075
Dave Santoro84cac442011-08-24 15:23:10 -07001076 // Remaining photos were not found in the contacts database (but might be in profile).
Flavio Lerdad33b18c2011-07-17 22:03:15 +01001077 for (Long id : mPhotoIds) {
Dave Santoro84cac442011-08-24 15:23:10 -07001078 if (ContactsContract.isProfileId(id)) {
1079 Cursor profileCursor = null;
1080 try {
1081 profileCursor = mResolver.query(
1082 ContentUris.withAppendedId(Data.CONTENT_URI, id),
1083 COLUMNS, null, null, null);
1084 if (profileCursor != null && profileCursor.moveToFirst()) {
1085 cacheBitmap(profileCursor.getLong(0), profileCursor.getBlob(1),
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001086 preloading, -1);
Dave Santoro84cac442011-08-24 15:23:10 -07001087 } else {
1088 // Couldn't load a photo this way either.
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001089 cacheBitmap(id, null, preloading, -1);
Dave Santoro84cac442011-08-24 15:23:10 -07001090 }
1091 } finally {
1092 if (profileCursor != null) {
1093 profileCursor.close();
1094 }
1095 }
1096 } else {
1097 // Not a profile photo and not found - mark the cache accordingly
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001098 cacheBitmap(id, null, preloading, -1);
Dave Santoro84cac442011-08-24 15:23:10 -07001099 }
Dmitri Plotnikov7edf2382011-01-31 16:15:48 -08001100 }
1101
1102 mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
1103 }
1104
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001105 /**
1106 * Loads photos referenced with Uris. Those can be remote thumbnails
1107 * (from directory searches), display photos etc
1108 */
1109 private void loadUriBasedPhotos() {
1110 for (Request uriRequest : mPhotoUris) {
1111 Uri uri = uriRequest.getUri();
Dmitri Plotnikoveb689432010-09-24 10:10:57 -07001112 if (mBuffer == null) {
1113 mBuffer = new byte[BUFFER_SIZE];
1114 }
1115 try {
Makoto Onuki8f8bd6d2011-11-08 14:09:01 -08001116 if (DEBUG) Log.d(TAG, "Loading " + uri);
Dmitri Plotnikoveb689432010-09-24 10:10:57 -07001117 InputStream is = mResolver.openInputStream(uri);
1118 if (is != null) {
1119 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1120 try {
1121 int size;
1122 while ((size = is.read(mBuffer)) != -1) {
1123 baos.write(mBuffer, 0, size);
1124 }
1125 } finally {
1126 is.close();
1127 }
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001128 cacheBitmap(uri, baos.toByteArray(), false,
1129 uriRequest.getRequestedExtent());
Dmitri Plotnikoveb689432010-09-24 10:10:57 -07001130 mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
Dmitri Plotnikov0f7462c2010-10-20 14:41:18 -07001131 } else {
1132 Log.v(TAG, "Cannot load photo " + uri);
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001133 cacheBitmap(uri, null, false, uriRequest.getRequestedExtent());
Dmitri Plotnikoveb689432010-09-24 10:10:57 -07001134 }
1135 } catch (Exception ex) {
1136 Log.v(TAG, "Cannot load photo " + uri, ex);
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001137 cacheBitmap(uri, null, false, uriRequest.getRequestedExtent());
Dmitri Plotnikoveb689432010-09-24 10:10:57 -07001138 }
Dmitri Plotnikov33409852010-02-20 15:02:32 -08001139 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -08001140 }
1141 }
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001142
1143 /**
1144 * A holder for either a Uri or an id and a flag whether this was requested for the dark or
1145 * light theme
1146 */
1147 private static final class Request {
1148 private final long mId;
1149 private final Uri mUri;
1150 private final boolean mDarkTheme;
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001151 private final int mRequestedExtent;
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001152 private final DefaultImageProvider mDefaultProvider;
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001153
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001154 private Request(long id, Uri uri, int requestedExtent, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001155 DefaultImageProvider defaultProvider) {
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001156 mId = id;
1157 mUri = uri;
1158 mDarkTheme = darkTheme;
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001159 mRequestedExtent = requestedExtent;
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001160 mDefaultProvider = defaultProvider;
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001161 }
1162
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001163 public static Request createFromThumbnailId(long id, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001164 DefaultImageProvider defaultProvider) {
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001165 return new Request(id, null /* no URI */, -1, darkTheme, defaultProvider);
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001166 }
1167
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001168 public static Request createFromUri(Uri uri, int requestedExtent, boolean darkTheme,
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001169 DefaultImageProvider defaultProvider) {
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001170 return new Request(0 /* no ID */, uri, requestedExtent, darkTheme, defaultProvider);
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001171 }
1172
1173 public boolean isUriRequest() {
1174 return mUri != null;
1175 }
1176
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001177 public Uri getUri() {
1178 return mUri;
1179 }
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001180
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001181 public long getId() {
1182 return mId;
1183 }
1184
1185 public int getRequestedExtent() {
1186 return mRequestedExtent;
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001187 }
1188
1189 @Override
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001190 public int hashCode() {
1191 final int prime = 31;
1192 int result = 1;
1193 result = prime * result + (int) (mId ^ (mId >>> 32));
1194 result = prime * result + mRequestedExtent;
1195 result = prime * result + ((mUri == null) ? 0 : mUri.hashCode());
1196 return result;
1197 }
1198
1199 @Override
1200 public boolean equals(Object obj) {
1201 if (this == obj) return true;
1202 if (obj == null) return false;
1203 if (getClass() != obj.getClass()) return false;
1204 final Request that = (Request) obj;
1205 if (mId != that.mId) return false;
1206 if (mRequestedExtent != that.mRequestedExtent) return false;
1207 if (!UriUtils.areEqual(mUri, that.mUri)) return false;
1208 // Don't compare equality of mDarkTheme because it is only used in the default contact
1209 // photo case. When the contact does have a photo, the contact photo is the same
1210 // regardless of mDarkTheme, so we shouldn't need to put the photo request on the queue
1211 // twice.
1212 return true;
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001213 }
1214
1215 public Object getKey() {
1216 return mUri == null ? mId : mUri;
1217 }
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001218
1219 public void applyDefaultImage(ImageView view) {
Daniel Lehmann2f77c852012-03-30 15:25:31 -07001220 mDefaultProvider.applyDefaultImage(view, mRequestedExtent, mDarkTheme);
Makoto Onuki3d3a15c2011-09-22 10:55:08 -07001221 }
Daniel Lehmannecfc26c2011-09-12 17:44:35 -07001222 }
Dmitri Plotnikove8643852010-02-17 10:49:05 -08001223}