Use Drawables for senders image. Less animation jank, less GC jank, less memory.
Protip: When testing sender images, go to your Sent folder. Tons of senders
images appear because you are most likely to talk to people in your address
book.
Rewrite UI to use modular Drawables. It's much easier to understand, since
Drawables with different functionality can be composed.
Flipping animation is 10x smoother. Handles quick double-tap on senders image
correctly.
Letter tiles are not allocated bitmaps anymore. They simply draw a rect and a
letter to the canvas.
We are no longer allocating large bitmaps for every list item. We reuse Bitmaps
whenever possible the same way that attachment previews do.
Much smaller 339KB cache since we don't share with attachment previews anymore,
just enough to fit 10 off-screen contact images.
Bug: 10429228
Change-Id: I463b63520d881eefe3974dccf295366831adaf9e
diff --git a/proguard.flags b/proguard.flags
index e0b2c23..7bab921 100644
--- a/proguard.flags
+++ b/proguard.flags
@@ -60,7 +60,6 @@
-keepclasseswithmembers class com.android.mail.browse.ConversationItemView {
*** setAnimatedHeightFraction(...);
- *** setPhotoFlipFraction(...);
}
-keepclasseswithmembers class com.android.mail.ui.MailActivity {
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 2693db7..0cfb9b2 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -93,10 +93,10 @@
<item>#ad62a7</item>
</array>
<color name="letter_tile_default_color">#d66161</color>
-
<color name="letter_tile_font_color">#ffffff</color>
-
<color name="tile_divider_color">#ffffff</color>
+ <!-- Color.GRAY -->
+ <color name="checkmark_tile_background_color">#ff888888</color>
<!-- Teaser colors -->
diff --git a/res/values/constants.xml b/res/values/constants.xml
index c238bf7..2f6cfc0 100644
--- a/res/values/constants.xml
+++ b/res/values/constants.xml
@@ -119,5 +119,5 @@
<integer name="ap_overflow_max_count">99</integer>
<!-- Duration of the animations for entering/exiting CAB mode -->
- <integer name="conv_item_view_cab_anim_duration">350</integer>
+ <integer name="conv_item_view_cab_anim_duration">250</integer>
</resources>
diff --git a/src/com/android/bitmap/AltBitmapCache.java b/src/com/android/bitmap/AltBitmapCache.java
index fb8e915..f519c7b 100644
--- a/src/com/android/bitmap/AltBitmapCache.java
+++ b/src/com/android/bitmap/AltBitmapCache.java
@@ -16,25 +16,40 @@
package com.android.bitmap;
+import com.android.bitmap.DecodeTask.Request;
+import com.android.bitmap.ReusableBitmap.NullReusableBitmap;
import com.android.mail.utils.LogTag;
import com.android.mail.utils.LogUtils;
+import com.android.mail.utils.LruCache;
/**
* This subclass provides custom pool behavior. The pool can be set to block on {@link #poll()} if
* nothing can be returned. This is useful if you know you will incur high costs upon receiving
* nothing from the pool, and you do not want to incur those costs at the critical moment when the
* UI is animating.
+ *
+ * This subclass provides custom cache behavior. Null values can be cached. Later,
+ * when the same key is used to retrieve the value, a {@link NullReusableBitmap} singleton will
+ * be returned.
*/
-public class AltBitmapCache extends AltPooledCache<DecodeTask.Request, ReusableBitmap>
+public class AltBitmapCache extends AltPooledCache<Request, ReusableBitmap>
implements BitmapCache {
private boolean mBlocking = false;
private final Object mLock = new Object();
+ private final LruCache<Request, Void> mNullRequests;
+
private final static boolean DEBUG = false;
private final static String TAG = LogTag.getLogTag();
- public AltBitmapCache(final int targetSizeBytes, final float nonPooledFraction) {
+ private int mDecodeWidth;
+ private int mDecodeHeight;
+
+ public AltBitmapCache(final int targetSizeBytes, final float nonPooledFraction,
+ final int nullCapacity) {
super(targetSizeBytes, nonPooledFraction);
+
+ mNullRequests = new LruCache<Request, Void>(nullCapacity);
}
/**
@@ -78,7 +93,7 @@
LogUtils.d(TAG, "AltBitmapCache: %s notified",
Thread.currentThread().getName());
}
- } catch (InterruptedException e) {
+ } catch (InterruptedException ignored) {
}
Trace.endSection();
}
@@ -95,4 +110,50 @@
mLock.notify();
}
}
+
+ @Override
+ public ReusableBitmap get(final Request key, final boolean incrementRefCount) {
+ if (mNullRequests.containsKey(key)) {
+ return NullReusableBitmap.getInstance();
+ }
+ return super.get(key, incrementRefCount);
+ }
+
+ @Override
+ public ReusableBitmap put(final Request key, final ReusableBitmap value) {
+ if (value == null || value == NullReusableBitmap.getInstance()) {
+ mNullRequests.put(key, null);
+ return null;
+ }
+
+ // Do not allow the pool to be filled with bitmaps that are of the wrong dimensions.
+ if (mDecodeWidth > value.bmp.getWidth() || mDecodeHeight > value.bmp.getHeight()) {
+ if (DEBUG) {
+ LogUtils.d(TAG, "Discarding ReusableBitmap size %d x %d for cache size %d x %d.",
+ value.bmp.getWidth(), value.bmp.getHeight(), mDecodeWidth, mDecodeHeight);
+ }
+ return null;
+ }
+
+ return super.put(key, value);
+ }
+
+ @Override
+ public void setPoolDimensions(final int decodeWidth, final int decodeHeight) {
+ if (mDecodeWidth < decodeWidth || mDecodeHeight < decodeHeight) {
+ clear();
+ mDecodeWidth = decodeWidth;
+ mDecodeHeight = decodeHeight;
+ }
+ }
+
+ @Override
+ public int getDecodeWidth() {
+ return mDecodeWidth;
+ }
+
+ @Override
+ public int getDecodeHeight() {
+ return mDecodeHeight;
+ }
}
diff --git a/src/com/android/bitmap/AltPooledCache.java b/src/com/android/bitmap/AltPooledCache.java
index 0a7d7b4..03a6c50 100644
--- a/src/com/android/bitmap/AltPooledCache.java
+++ b/src/com/android/bitmap/AltPooledCache.java
@@ -67,6 +67,7 @@
@Override
public V get(K key, boolean incrementRefCount) {
+ Trace.beginSection("cache get");
synchronized (mCache) {
V result = mCache.get(key);
if (result == null && mNonPooledCache != null) {
@@ -75,12 +76,14 @@
if (incrementRefCount && result != null) {
result.acquireReference();
}
+ Trace.endSection();
return result;
}
}
@Override
public V put(K key, V value) {
+ Trace.beginSection("cache put");
synchronized (mCache) {
final V prev;
if (value.isEligibleForPooling()) {
@@ -90,22 +93,27 @@
} else {
prev = null;
}
+ Trace.endSection();
return prev;
}
}
@Override
public void offer(V value) {
+ Trace.beginSection("pool offer");
if (value.getRefCount() != 0 || !value.isEligibleForPooling()) {
throw new IllegalArgumentException("unexpected offer of an invalid object: " + value);
}
mPool.offer(value);
+ Trace.endSection();
}
@Override
public V poll() {
+ Trace.beginSection("pool poll");
final V pooled = mPool.poll();
if (pooled != null) {
+ Trace.endSection();
return pooled;
}
@@ -131,11 +139,13 @@
if (DEBUG) System.err.println(
"POOL SCAVENGE FAILED, cache not fully warm yet. szDelta="
+ (mTargetSize-unrefSize));
+ Trace.endSection();
return null;
} else {
mCache.remove(eldestUnref.getKey());
if (DEBUG) System.err.println("POOL SCAVENGE SUCCESS, oldKey="
+ eldestUnref.getKey());
+ Trace.endSection();
return eldestUnref.getValue();
}
}
@@ -209,4 +219,9 @@
}
+ @Override
+ public void clear() {
+ mCache.clear();
+ mPool.clear();
+ }
}
diff --git a/src/com/android/bitmap/BitmapCache.java b/src/com/android/bitmap/BitmapCache.java
index d671c17..fc76c3a 100644
--- a/src/com/android/bitmap/BitmapCache.java
+++ b/src/com/android/bitmap/BitmapCache.java
@@ -19,4 +19,7 @@
public interface BitmapCache extends PooledCache<DecodeTask.Request, ReusableBitmap> {
void setBlocking(boolean blocking);
+ void setPoolDimensions(int decodeWidth, int decodeHeight);
+ int getDecodeWidth();
+ int getDecodeHeight();
}
diff --git a/src/com/android/bitmap/DecodeTask.java b/src/com/android/bitmap/DecodeTask.java
index 8fa11f1..d7a3cab 100644
--- a/src/com/android/bitmap/DecodeTask.java
+++ b/src/com/android/bitmap/DecodeTask.java
@@ -66,8 +66,6 @@
* may have been preempted by the scheduler or queued up by a bottlenecked executor.
* <p>
* N.B. this method runs on the UI thread.
- *
- * @param key
*/
void onDecodeBegin(Request key);
void onDecodeComplete(Request key, ReusableBitmap result);
@@ -87,13 +85,17 @@
@Override
protected ReusableBitmap doInBackground(Void... params) {
+ // enqueue the 'onDecodeBegin' signal on the main thread
+ publishProgress();
+
+ return decode();
+ }
+
+ public ReusableBitmap decode() {
if (isCancelled()) {
return null;
}
- // enqueue the 'onDecodeBegin' signal on the main thread
- publishProgress();
-
ReusableBitmap result = null;
AssetFileDescriptor fd = null;
InputStream in = null;
@@ -146,7 +148,7 @@
try {
// Close the temporary file descriptor.
in.close();
- } catch (IOException ex) {
+ } catch (IOException ignored) {
}
}
} else {
@@ -253,6 +255,7 @@
}
}
+ //noinspection PointlessBooleanExpression
if (!CROP_DURING_DECODE || (decodeResult == null && !isCancelled())) {
try {
Trace.beginSection("decode" + mOpts.inSampleSize);
@@ -314,13 +317,13 @@
if (fd != null) {
try {
fd.close();
- } catch (IOException e) {
+ } catch (IOException ignored) {
}
}
if (in != null) {
try {
in.close();
- } catch (IOException e) {
+ } catch (IOException ignored) {
}
}
if (result != null) {
@@ -395,7 +398,7 @@
} else {
try {
in.close();
- } catch (IOException ex) {
+ } catch (IOException ignored) {
}
in = mKey.createInputStream();
}
@@ -421,6 +424,7 @@
// round to the nearest power of two, or just truncate
final boolean stricter = true;
+ //noinspection ConstantConditions
if (stricter) {
result = (int) Math.pow(2, (int) (0.5 + (Math.log(sz) / Math.log(2))));
} else {
diff --git a/src/com/android/bitmap/PooledCache.java b/src/com/android/bitmap/PooledCache.java
index 62381b8..6d6684f 100644
--- a/src/com/android/bitmap/PooledCache.java
+++ b/src/com/android/bitmap/PooledCache.java
@@ -24,4 +24,14 @@
V poll();
String toDebugString();
+ /**
+ * Purge existing Poolables from the pool+cache. Usually, this is done when situations
+ * change and the items in the pool+cache are no longer appropriate. For example,
+ * if the layout changes, the pool+cache may need to hold larger bitmaps.
+ *
+ * <p/>
+ * The existing Poolables will be garbage collected when they are no longer being referenced
+ * by other objects.
+ */
+ void clear();
}
diff --git a/src/com/android/bitmap/ReusableBitmap.java b/src/com/android/bitmap/ReusableBitmap.java
index 2e0199f..dde9bd1 100644
--- a/src/com/android/bitmap/ReusableBitmap.java
+++ b/src/com/android/bitmap/ReusableBitmap.java
@@ -115,4 +115,37 @@
return sb.toString();
}
+ /**
+ * Singleton class to represent a null Bitmap. We don't want to just use a regular
+ * ReusableBitmap with a null bmp field because that will render that ReusableBitmap useless
+ * and unable to be used by another decode process.
+ */
+ public final static class NullReusableBitmap extends ReusableBitmap {
+ private static NullReusableBitmap sInstance;
+
+ /**
+ * Get a singleton.
+ */
+ public static NullReusableBitmap getInstance() {
+ if (sInstance == null) {
+ sInstance = new NullReusableBitmap();
+ }
+ return sInstance;
+ }
+
+ private NullReusableBitmap() {
+ super(null /* bmp */, false /* reusable */);
+ }
+
+ @Override
+ public int getByteCount() {
+ return 0;
+ }
+
+ @Override
+ public void releaseReference() { }
+
+ @Override
+ public void acquireReference() { }
+ }
}
diff --git a/src/com/android/mail/ContactInfo.java b/src/com/android/mail/ContactInfo.java
index b7cecb8..a59dc62 100644
--- a/src/com/android/mail/ContactInfo.java
+++ b/src/com/android/mail/ContactInfo.java
@@ -47,6 +47,6 @@
@Override
public String toString() {
- return "{status=" + status + " photo=" + photo + "}";
+ return "{status=" + status + " photo=" + (photo != null ? photo : photoBytes) + "}";
}
}
diff --git a/src/com/android/mail/SenderInfoLoader.java b/src/com/android/mail/SenderInfoLoader.java
index 5d01ad4..c69e934 100644
--- a/src/com/android/mail/SenderInfoLoader.java
+++ b/src/com/android/mail/SenderInfoLoader.java
@@ -17,6 +17,7 @@
package com.android.mail;
+import com.android.bitmap.Trace;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
@@ -99,40 +100,53 @@
/**
* Loads contact photos from the ContentProvider.
* @param resolver {@link ContentResolver} to use in queries to the ContentProvider.
- * @param senderSet The email addresses of the sender images to return.
+ * @param emails The email addresses of the sender images to return.
* @param decodeBitmaps If {@code true}, decode the bitmaps and put them into
* {@link ContactInfo}. Otherwise, just put the raw bytes of the photo
* into the {@link ContactInfo}.
- * @return A mapping of email addresses to {@link ContactInfo}s. The {@link ContactInfo} will
- * contain either a byte array or an actual decoded bitmap for the sender image.
+ * @return A mapping of email to {@link ContactInfo}. How to interpret the map:
+ * <ul>
+ * <li>The email is missing from the key set or maps to null - The email was skipped. Try
+ * again.</li>
+ * <li>Either {@link ContactInfo#photoBytes} or {@link ContactInfo#photo} is non-null -
+ * Photo loaded successfully.</li>
+ * <li>Both {@link ContactInfo#photoBytes} and {@link ContactInfo#photo} are null -
+ * Photo load failed.</li>
+ * </ul>
*/
public static ImmutableMap<String, ContactInfo> loadContactPhotos(
- final ContentResolver resolver, final Set<String> senderSet,
- final boolean decodeBitmaps) {
+ final ContentResolver resolver, final Set<String> emails, final boolean decodeBitmaps) {
+ Trace.beginSection("load contact photos util");
Cursor cursor = null;
+ Trace.beginSection("build first query");
Map<String, ContactInfo> results = Maps.newHashMap();
// temporary structures
Map<Long, Pair<String, ContactInfo>> photoIdMap = Maps.newHashMap();
ArrayList<String> photoIdsAsStrings = new ArrayList<String>();
- ArrayList<String> senders = getTruncatedQueryParams(senderSet);
+ ArrayList<String> emailsList = getTruncatedQueryParams(emails);
// Build first query
StringBuilder query = new StringBuilder()
.append(Data.MIMETYPE).append("='").append(Email.CONTENT_ITEM_TYPE)
.append("' AND ").append(Email.DATA).append(" IN (");
- appendQuestionMarks(query, senders);
+ appendQuestionMarks(query, emailsList);
query.append(')');
+ Trace.endSection();
try {
+ Trace.beginSection("query 1");
cursor = resolver.query(Data.CONTENT_URI, DATA_COLS,
- query.toString(), toStringArray(senders), null /* sortOrder */);
+ query.toString(), toStringArray(emailsList), null /* sortOrder */);
+ Trace.endSection();
if (cursor == null) {
+ Trace.endSection();
return null;
}
+ Trace.beginSection("get photo id");
int i = -1;
while (cursor.moveToPosition(++i)) {
String email = cursor.getString(DATA_EMAIL_COLUMN);
@@ -154,11 +168,23 @@
results.put(email, result);
}
cursor.close();
+ Trace.endSection();
+
+ // Put empty ContactInfo for all the emails that didn't map to a contact.
+ // This allows us to differentiate between lookup failed,
+ // and lookup skipped (truncated above).
+ for (String email : emailsList) {
+ if (!results.containsKey(email)) {
+ results.put(email, new ContactInfo(null, null));
+ }
+ }
if (photoIdsAsStrings.isEmpty()) {
+ Trace.endSection();
return ImmutableMap.copyOf(results);
}
+ Trace.beginSection("build second query");
// Build second query: photoIDs->blobs
// based on photo batch-select code in ContactPhotoManager
photoIdsAsStrings = getTruncatedQueryParams(photoIdsAsStrings);
@@ -166,14 +192,19 @@
query.append(Photo._ID).append(" IN (");
appendQuestionMarks(query, photoIdsAsStrings);
query.append(')');
+ Trace.endSection();
+ Trace.beginSection("query 2");
cursor = resolver.query(Data.CONTENT_URI, PHOTO_COLS,
query.toString(), toStringArray(photoIdsAsStrings), null /* sortOrder */);
+ Trace.endSection();
if (cursor == null) {
+ Trace.endSection();
return ImmutableMap.copyOf(results);
}
+ Trace.beginSection("get photo blob");
i = -1;
while (cursor.moveToPosition(++i)) {
byte[] photoBytes = cursor.getBlob(PHOTO_PHOTO_COLUMN);
@@ -187,7 +218,9 @@
ContactInfo prevResult = prev.second;
if (decodeBitmaps) {
+ Trace.beginSection("decode bitmap");
Bitmap photo = BitmapFactory.decodeByteArray(photoBytes, 0, photoBytes.length);
+ Trace.endSection();
// overwrite existing photo-less result
results.put(email,
new ContactInfo(prevResult.contactUri, prevResult.status, photo));
@@ -197,12 +230,14 @@
prevResult.contactUri, prevResult.status, photoBytes));
}
}
+ Trace.endSection();
} finally {
if (cursor != null) {
cursor.close();
}
}
+ Trace.endSection();
return ImmutableMap.copyOf(results);
}
diff --git a/src/com/android/mail/bitmap/AttachmentDrawable.java b/src/com/android/mail/bitmap/AttachmentDrawable.java
index 0252455..49e4008 100644
--- a/src/com/android/mail/bitmap/AttachmentDrawable.java
+++ b/src/com/android/mail/bitmap/AttachmentDrawable.java
@@ -147,11 +147,13 @@
// requests for different renditions of the same attachment
final boolean onlyRenditionChange = (mCurrKey != null && mCurrKey.matches(key));
+ Trace.beginSection("release reference");
if (mBitmap != null && !onlyRenditionChange) {
mBitmap.releaseReference();
// System.out.println("view.bind() decremented ref to old bitmap: " + mBitmap);
mBitmap = null;
}
+ Trace.endSection();
if (mCurrKey != null && SwipeableListView.ENABLE_ATTACHMENT_DECODE_AGGREGATOR) {
mDecodeAggregator.forget(mCurrKey);
}
@@ -169,6 +171,7 @@
setLoadState(LOAD_STATE_UNINITIALIZED);
if (key == null) {
+ invalidateSelf();
Trace.endSection();
return;
}
@@ -200,7 +203,7 @@
return;
}
- if (mBitmap != null) {
+ if (mBitmap != null && mBitmap.bmp != null) {
BitmapUtils
.calculateCroppedSrcRect(mBitmap.getLogicalWidth(), mBitmap.getLogicalHeight(),
bounds.width(), bounds.height(),
diff --git a/src/com/android/mail/bitmap/AttachmentGridDrawable.java b/src/com/android/mail/bitmap/AttachmentGridDrawable.java
index f5d28ed..c1e5789 100644
--- a/src/com/android/mail/bitmap/AttachmentGridDrawable.java
+++ b/src/com/android/mail/bitmap/AttachmentGridDrawable.java
@@ -2,6 +2,7 @@
import android.content.res.Resources;
import android.graphics.Canvas;
+import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Rect;
@@ -47,7 +48,7 @@
}
@Override
- protected AttachmentDrawable createDivisionDrawable() {
+ protected AttachmentDrawable createDivisionDrawable(final int i) {
final AttachmentDrawable result = new AttachmentDrawable(mResources, mCache,
mDecodeAggregator, mCoordinates, mPlaceholder, mProgress);
return result;
@@ -105,8 +106,24 @@
}
@Override
+ public void setAlpha(final int alpha) {
+ super.setAlpha(alpha);
+ final int old = mPaint.getAlpha();
+ mPaint.setAlpha(alpha);
+ if (alpha != old) {
+ invalidateSelf();
+ }
+ }
+
+ @Override
+ public void setColorFilter(final ColorFilter cf) {
+ super.setColorFilter(cf);
+ mPaint.setColorFilter(cf);
+ invalidateSelf();
+ }
+
+ @Override
public void setParallaxFraction(float fraction) {
mParallaxFraction = fraction;
}
-
}
diff --git a/src/com/android/mail/bitmap/CompositeDrawable.java b/src/com/android/mail/bitmap/CompositeDrawable.java
index e25bfc7..e372bb5 100644
--- a/src/com/android/mail/bitmap/CompositeDrawable.java
+++ b/src/com/android/mail/bitmap/CompositeDrawable.java
@@ -21,11 +21,13 @@
public abstract class CompositeDrawable<T extends Drawable> extends Drawable
implements Drawable.Callback {
+ public static final int MAX_COMPOSITE_DRAWABLES = 4;
+
protected final List<T> mDrawables;
protected int mCount;
public CompositeDrawable(int maxDivisions) {
- if (maxDivisions >= 4) {
+ if (maxDivisions > MAX_COMPOSITE_DRAWABLES) {
throw new IllegalArgumentException("CompositeDrawable only supports 4 divisions");
}
mDrawables = new ArrayList<T>(maxDivisions);
@@ -35,7 +37,7 @@
mCount = 0;
}
- protected abstract T createDivisionDrawable();
+ protected abstract T createDivisionDrawable(final int i);
public void setCount(int count) {
// zero out the composite bounds, which will propagate to the division drawables
@@ -56,7 +58,7 @@
T result = mDrawables.get(i);
if (result == null) {
Trace.beginSection("create division drawable");
- result = createDivisionDrawable();
+ result = createDivisionDrawable(i);
mDrawables.set(i, result);
result.setCallback(this);
// Make sure drawables created after the bounds were already set have their bounds
@@ -109,6 +111,11 @@
@Override
public void draw(Canvas canvas) {
+ final Rect bounds = getBounds();
+ if (!isVisible() || bounds.isEmpty()) {
+ return;
+ }
+
for (int i = 0; i < mCount; i++) {
mDrawables.get(i).draw(canvas);
}
@@ -132,10 +139,7 @@
public int getOpacity() {
int opacity = PixelFormat.OPAQUE;
for (int i = 0; i < mCount; i++) {
- if (mDrawables.get(i).getOpacity() != PixelFormat.OPAQUE) {
- opacity = PixelFormat.TRANSLUCENT;
- break;
- }
+ opacity = resolveOpacity(opacity, mDrawables.get(i).getOpacity());
}
return opacity;
}
diff --git a/src/com/android/mail/bitmap/ContactCheckableGridDrawable.java b/src/com/android/mail/bitmap/ContactCheckableGridDrawable.java
new file mode 100644
index 0000000..134439d
--- /dev/null
+++ b/src/com/android/mail/bitmap/ContactCheckableGridDrawable.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.mail.bitmap;
+
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+
+import com.android.bitmap.BitmapCache;
+import com.android.mail.R.color;
+import com.android.mail.R.drawable;
+
+/**
+ * Custom FlipDrawable which has a {@link ContactGridDrawable} on the front,
+ * and a {@link CheckmarkDrawable} on the back.
+ */
+public class ContactCheckableGridDrawable extends FlipDrawable implements AnimatorUpdateListener {
+
+ private final ContactGridDrawable mContactGridDrawable;
+ private final CheckmarkDrawable mCheckmarkDrawable;
+
+ private final ValueAnimator mCheckmarkScaleAnimator;
+ private final ValueAnimator mCheckmarkAlphaAnimator;
+
+ private static final int POST_FLIP_DURATION_MS = 150;
+
+ private static final float CHECKMARK_SCALE_BEGIN_VALUE = 0.2f;
+ private static final float CHECKMARK_ALPHA_BEGIN_VALUE = 0f;
+
+ /** Must be <= 1f since the animation value is used as a percentage. */
+ private static final float END_VALUE = 1f;
+
+ public ContactCheckableGridDrawable(final Resources res, final int flipDurationMs) {
+ super(new ContactGridDrawable(res), new CheckmarkDrawable(res), flipDurationMs,
+ 0 /* preFlipDurationMs */, POST_FLIP_DURATION_MS);
+
+ mContactGridDrawable = (ContactGridDrawable) mFront;
+ mCheckmarkDrawable = (CheckmarkDrawable) mBack;
+
+ // We will create checkmark animations that are synchronized with the flipping animation.
+ // The entire delay + duration of the checkmark animation needs to equal the entire
+ // duration of the flip animation (where delay is 0).
+
+ // The checkmark animation is in effect only when the back drawable is being shown.
+ // For the flip animation duration <pre>[_][]|[][_]<post>
+ // The checkmark animation will be |--delay--|-duration-|
+
+ // Need delay to skip the first half of the flip duration.
+ final long animationDelay = mPreFlipDurationMs + mFlipDurationMs / 2;
+ // Actual duration is the second half of the flip duration.
+ final long animationDuration = mFlipDurationMs / 2 + mPostFlipDurationMs;
+
+ mCheckmarkScaleAnimator = ValueAnimator.ofFloat(CHECKMARK_SCALE_BEGIN_VALUE, END_VALUE)
+ .setDuration(animationDuration);
+ mCheckmarkScaleAnimator.setStartDelay(animationDelay);
+ mCheckmarkScaleAnimator.addUpdateListener(this);
+
+ mCheckmarkAlphaAnimator = ValueAnimator.ofFloat(CHECKMARK_ALPHA_BEGIN_VALUE, END_VALUE)
+ .setDuration(animationDuration);
+ mCheckmarkAlphaAnimator.setStartDelay(animationDelay);
+ mCheckmarkAlphaAnimator.addUpdateListener(this);
+ }
+
+ @Override
+ public void reset(final boolean side) {
+ super.reset(side);
+ if (mCheckmarkScaleAnimator == null) {
+ // Call from super's constructor. Not yet initialized.
+ return;
+ }
+ mCheckmarkScaleAnimator.cancel();
+ mCheckmarkAlphaAnimator.cancel();
+ mCheckmarkDrawable.setScaleAnimatorValue(side ? CHECKMARK_SCALE_BEGIN_VALUE : END_VALUE);
+ mCheckmarkDrawable.setAlphaAnimatorValue(side ? CHECKMARK_ALPHA_BEGIN_VALUE : END_VALUE);
+ }
+
+ @Override
+ public void flip() {
+ super.flip();
+ // Keep the checkmark animators in sync with the flip animator.
+ if (mCheckmarkScaleAnimator.isStarted()) {
+ mCheckmarkScaleAnimator.reverse();
+ mCheckmarkAlphaAnimator.reverse();
+ } else {
+ if (!getSideFlippingTowards() /* front to back */) {
+ mCheckmarkScaleAnimator.start();
+ mCheckmarkAlphaAnimator.start();
+ } else /* back to front */ {
+ mCheckmarkScaleAnimator.reverse();
+ mCheckmarkAlphaAnimator.reverse();
+ }
+ }
+ }
+
+ public ContactDrawable getOrCreateDrawable(final int i) {
+ return mContactGridDrawable.getOrCreateDrawable(i);
+ }
+
+ public void setBitmapCache(final BitmapCache cache) {
+ mContactGridDrawable.setBitmapCache(cache);
+ }
+
+ public void setContactResolver(final ContactResolver contactResolver) {
+ mContactGridDrawable.setContactResolver(contactResolver);
+ }
+
+ public int getCount() {
+ return mContactGridDrawable.getCount();
+ }
+
+ public void setCount(final int count) {
+ mContactGridDrawable.setCount(count);
+ // Side effect needs to happen here too.
+ setBounds(0, 0, 0, 0);
+ }
+
+ @Override
+ public void onAnimationUpdate(final ValueAnimator animation) {
+ //noinspection ConstantConditions
+ final float value = (Float) animation.getAnimatedValue();
+
+ if (animation == mCheckmarkScaleAnimator) {
+ mCheckmarkDrawable.setScaleAnimatorValue(value);
+ } else if (animation == mCheckmarkAlphaAnimator) {
+ mCheckmarkDrawable.setAlphaAnimatorValue(value);
+ }
+ }
+
+ /**
+ * Meant to be used as the with a FlipDrawable. The animator driving this Drawable should be
+ * more or less in sync with the containing FlipDrawable's flip animator.
+ */
+ private static class CheckmarkDrawable extends Drawable {
+
+ private static Bitmap CHECKMARK;
+ private static int sBackgroundColor;
+
+ private final Paint mPaint;
+
+ private float mScaleFraction;
+ private float mAlphaFraction;
+
+ private static final Matrix sMatrix = new Matrix();
+
+ public CheckmarkDrawable(final Resources res) {
+ if (CHECKMARK == null) {
+ CHECKMARK = BitmapFactory.decodeResource(res, drawable.ic_avatar_check);
+ sBackgroundColor = res.getColor(color.checkmark_tile_background_color);
+ }
+ mPaint = new Paint();
+ mPaint.setAntiAlias(true);
+ mPaint.setFilterBitmap(true);
+ mPaint.setColor(sBackgroundColor);
+ }
+
+ @Override
+ public void draw(final Canvas canvas) {
+ final Rect bounds = getBounds();
+ if (!isVisible() || bounds.isEmpty()) {
+ return;
+ }
+
+ canvas.drawRect(getBounds(), mPaint);
+
+ // Scale the checkmark.
+ sMatrix.reset();
+ sMatrix.setScale(mScaleFraction, mScaleFraction, CHECKMARK.getWidth() / 2,
+ CHECKMARK.getHeight() / 2);
+ sMatrix.postTranslate(bounds.centerX() - CHECKMARK.getWidth() / 2,
+ bounds.centerY() - CHECKMARK.getHeight() / 2);
+
+ // Fade the checkmark.
+ final int oldAlpha = mPaint.getAlpha();
+ // Interpolate the alpha.
+ mPaint.setAlpha((int) (oldAlpha * mAlphaFraction));
+ canvas.drawBitmap(CHECKMARK, sMatrix, mPaint);
+ // Restore the alpha.
+ mPaint.setAlpha(oldAlpha);
+ }
+
+ @Override
+ public void setAlpha(final int alpha) {
+ mPaint.setAlpha(alpha);
+ }
+
+ @Override
+ public void setColorFilter(final ColorFilter cf) {
+ mPaint.setColorFilter(cf);
+ }
+
+ @Override
+ public int getOpacity() {
+ // Always a gray background.
+ return PixelFormat.OPAQUE;
+ }
+
+ /**
+ * Set value as a fraction from 0f to 1f.
+ */
+ public void setScaleAnimatorValue(final float value) {
+ final float old = mScaleFraction;
+ mScaleFraction = value;
+ if (old != mScaleFraction) {
+ invalidateSelf();
+ }
+ }
+
+ /**
+ * Set value as a fraction from 0f to 1f.
+ */
+ public void setAlphaAnimatorValue(final float value) {
+ final float old = mAlphaFraction;
+ mAlphaFraction = value;
+ if (old != mAlphaFraction) {
+ invalidateSelf();
+ }
+ }
+ }
+}
diff --git a/src/com/android/mail/bitmap/ContactDrawable.java b/src/com/android/mail/bitmap/ContactDrawable.java
new file mode 100644
index 0000000..34aa682
--- /dev/null
+++ b/src/com/android/mail/bitmap/ContactDrawable.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.mail.bitmap;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Paint.Align;
+import android.graphics.Rect;
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+
+import com.android.bitmap.BitmapCache;
+import com.android.bitmap.DecodeTask.Request;
+import com.android.bitmap.ReusableBitmap;
+import com.android.mail.R;
+
+/**
+ * A drawable that encapsulates all the functionality needed to display a contact image,
+ * including request creation/cancelling and data unbinding/re-binding. While no contact images
+ * can be shown, a default letter tile will be shown instead.
+ *
+ * <p/>
+ * The actual contact resolving and decoding is handled by {@link ContactResolver}.
+ */
+public class ContactDrawable extends Drawable {
+
+ private final BitmapCache mCache;
+ private final ContactResolver mContactResolver;
+
+ private ContactRequest mContactRequest;
+ private ReusableBitmap mBitmap;
+ private final Paint mPaint;
+ private int mScale;
+
+ /** Letter tile */
+ private static TypedArray sColors;
+ private static int sDefaultColor;
+ private static int sTileLetterFontSize;
+ private static int sTileLetterFontSizeSmall;
+ private static int sTileFontColor;
+ private static Bitmap DEFAULT_AVATAR;
+ /** Reusable components to avoid new allocations */
+ private static final Paint sPaint = new Paint();
+ private static final Rect sRect = new Rect();
+ private static final char[] sFirstChar = new char[1];
+
+ /** This should match the total number of colors defined in colors.xml for letter_tile_color */
+ private static final int NUM_OF_TILE_COLORS = 8;
+
+ public ContactDrawable(final Resources res, final BitmapCache cache,
+ final ContactResolver contactResolver) {
+ mCache = cache;
+ mContactResolver = contactResolver;
+ mPaint = new Paint();
+ mPaint.setFilterBitmap(true);
+ mPaint.setDither(true);
+
+ if (sColors == null) {
+ sColors = res.obtainTypedArray(R.array.letter_tile_colors);
+ sDefaultColor = res.getColor(R.color.letter_tile_default_color);
+ sTileLetterFontSize = res.getDimensionPixelSize(R.dimen.tile_letter_font_size);
+ sTileLetterFontSizeSmall = res
+ .getDimensionPixelSize(R.dimen.tile_letter_font_size_small);
+ sTileFontColor = res.getColor(R.color.letter_tile_font_color);
+ DEFAULT_AVATAR = BitmapFactory.decodeResource(res, R.drawable.ic_generic_man);
+
+ sPaint.setTypeface(Typeface.create("sans-serif-light", Typeface.NORMAL));
+ sPaint.setTextAlign(Align.CENTER);
+ sPaint.setAntiAlias(true);
+ }
+ }
+
+ @Override
+ public void draw(final Canvas canvas) {
+ final Rect bounds = getBounds();
+ if (!isVisible() || bounds.isEmpty()) {
+ return;
+ }
+
+ if (mBitmap != null && mBitmap.bmp != null) {
+ // Draw sender image.
+ drawBitmap(mBitmap.bmp, mBitmap.getLogicalWidth(), mBitmap.getLogicalHeight(), canvas);
+ } else {
+ // Draw letter tile.
+ drawLetterTile(canvas);
+ }
+ }
+
+ /**
+ * Draw the bitmap onto the canvas at the current bounds taking into account the current scale.
+ */
+ private void drawBitmap(final Bitmap bitmap, final int width, final int height,
+ final Canvas canvas) {
+ final Rect bounds = getBounds();
+
+ if (mScale != ContactGridDrawable.SCALE_TYPE_HALF) {
+ sRect.set(0, 0, width, height);
+ } else {
+ // For skinny bounds, draw the middle two quarters.
+ sRect.set(width / 4, 0, width / 4 * 3, height);
+ }
+ canvas.drawBitmap(bitmap, sRect, bounds, mPaint);
+ }
+
+ private void drawLetterTile(final Canvas canvas) {
+ if (mContactRequest == null) {
+ return;
+ }
+
+ // Draw background color.
+ final String email = mContactRequest.getEmail();
+ sPaint.setColor(pickColor(email));
+ sPaint.setAlpha(mPaint.getAlpha());
+ canvas.drawRect(getBounds(), sPaint);
+
+ // Draw letter/digit or generic avatar.
+ final String displayName = mContactRequest.getDisplayName();
+ final char firstChar = displayName.charAt(0);
+ final Rect bounds = getBounds();
+ if (isEnglishLetterOrDigit(firstChar)) {
+ // Draw letter or digit.
+ sFirstChar[0] = Character.toUpperCase(firstChar);
+ sPaint.setTextSize(mScale == ContactGridDrawable.SCALE_TYPE_ONE ? sTileLetterFontSize
+ : sTileLetterFontSizeSmall);
+ sPaint.getTextBounds(sFirstChar, 0, 1, sRect);
+ sPaint.setColor(sTileFontColor);
+ canvas.drawText(sFirstChar, 0, 1, bounds.centerX(),
+ bounds.centerY() + sRect.height() / 2, sPaint);
+ } else {
+ drawBitmap(DEFAULT_AVATAR, DEFAULT_AVATAR.getWidth(), DEFAULT_AVATAR.getHeight(),
+ canvas);
+ }
+ }
+
+ private static int pickColor(final String email) {
+ // String.hashCode() implementation is not supposed to change across java versions, so
+ // this should guarantee the same email address always maps to the same color.
+ // The email should already have been normalized by the ContactRequest.
+ final int color = Math.abs(email.hashCode()) % NUM_OF_TILE_COLORS;
+ return sColors.getColor(color, sDefaultColor);
+ }
+
+ private static boolean isEnglishLetterOrDigit(final char c) {
+ return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9');
+ }
+
+ @Override
+ public void setAlpha(final int alpha) {
+ mPaint.setAlpha(alpha);
+ }
+
+ @Override
+ public void setColorFilter(final ColorFilter cf) {
+ mPaint.setColorFilter(cf);
+ }
+
+ @Override
+ public int getOpacity() {
+ return 0;
+ }
+
+ public void setDecodeDimensions(final int decodeWidth, final int decodeHeight) {
+ mCache.setPoolDimensions(decodeWidth, decodeHeight);
+ }
+
+ public void setScale(final int scale) {
+ mScale = scale;
+ }
+
+ public void unbind() {
+ setImage(null);
+ }
+
+ public void bind(final String name, final String email) {
+ setImage(new ContactRequest(name, email));
+ }
+
+ private void setImage(final ContactRequest contactRequest) {
+ if (mContactRequest != null && mContactRequest.equals(contactRequest)) {
+ return;
+ }
+
+ if (mBitmap != null) {
+ mBitmap.releaseReference();
+ mBitmap = null;
+ }
+
+ mContactResolver.remove(mContactRequest, this);
+ mContactRequest = contactRequest;
+
+ if (contactRequest == null) {
+ invalidateSelf();
+ return;
+ }
+
+ final ReusableBitmap cached = mCache.get(contactRequest, true /* incrementRefCount */);
+ if (cached != null) {
+ setBitmap(cached);
+ } else {
+ decode();
+ }
+ }
+
+ private void setBitmap(final ReusableBitmap bmp) {
+ if (mBitmap != null && mBitmap != bmp) {
+ mBitmap.releaseReference();
+ }
+ mBitmap = bmp;
+ invalidateSelf();
+ }
+
+ private void decode() {
+ if (mContactRequest == null) {
+ return;
+ }
+ // Add to batch.
+ mContactResolver.add(mContactRequest, this);
+ }
+
+ public void onDecodeComplete(final Request key, final ReusableBitmap result) {
+ final ContactRequest request = (ContactRequest) key;
+ // Remove from batch.
+ mContactResolver.remove(request, this);
+ if (request.equals(mContactRequest)) {
+ setBitmap(result);
+ } else {
+ // if the requests don't match (i.e. this request is stale), decrement the
+ // ref count to allow the bitmap to be pooled
+ if (result != null) {
+ result.releaseReference();
+ }
+ }
+ }
+}
diff --git a/src/com/android/mail/bitmap/ContactGridDrawable.java b/src/com/android/mail/bitmap/ContactGridDrawable.java
new file mode 100644
index 0000000..590f806
--- /dev/null
+++ b/src/com/android/mail/bitmap/ContactGridDrawable.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.mail.bitmap;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Rect;
+
+import com.android.bitmap.BitmapCache;
+import com.android.mail.R;
+
+/**
+ * A 2x2 grid of contact drawables. Adds horizontal and vertical dividers.
+ */
+public class ContactGridDrawable extends CompositeDrawable<ContactDrawable> {
+
+ public static final int SCALE_TYPE_ONE = 0;
+ public static final int SCALE_TYPE_HALF = 1;
+ public static final int SCALE_TYPE_QUARTER = 2;
+
+ private static final int MAX_CONTACTS_COUNT = 4;
+
+ private ContactResolver mContactResolver;
+ private BitmapCache mCache;
+ private final Resources mRes;
+ private Paint mPaint;
+
+ private static int sDividerWidth = -1;
+ private static int sDividerColor;
+
+ public ContactGridDrawable(final Resources res) {
+ super(MAX_CONTACTS_COUNT);
+
+ if (sDividerWidth == -1) {
+ sDividerWidth = res.getDimensionPixelSize(R.dimen.tile_divider_width);
+ sDividerColor = res.getColor(R.color.tile_divider_color);
+ }
+
+ mRes = res;
+ mPaint = new Paint();
+ mPaint.setStrokeWidth(sDividerWidth);
+ mPaint.setColor(sDividerColor);
+ }
+
+ @Override
+ protected ContactDrawable createDivisionDrawable(final int i) {
+ final ContactDrawable drawable = new ContactDrawable(mRes, mCache, mContactResolver);
+ drawable.setScale(calculateScale(i));
+ return drawable;
+ }
+
+ @Override
+ public void setCount(final int count) {
+ super.setCount(count);
+
+ for (int i = 0; i < mCount; i++) {
+ final ContactDrawable drawable = mDrawables.get(i);
+ if (drawable != null) {
+ drawable.setScale(calculateScale(i));
+ }
+ }
+ }
+
+ /**
+ * Given which section a drawable is in, calculate its scale based on the current total count.
+ * @param i The section, indexed by 0.
+ */
+ private int calculateScale(final int i) {
+ switch (mCount) {
+ case 1:
+ // 1 bitmap: passthrough
+ return SCALE_TYPE_ONE;
+ case 2:
+ // 2 bitmaps split vertically
+ return SCALE_TYPE_HALF;
+ case 3:
+ // 1st is tall on the left, 2nd/3rd stacked vertically on the right
+ return i == 0 ? SCALE_TYPE_HALF : SCALE_TYPE_QUARTER;
+ case 4:
+ // 4 bitmaps in a 2x2 grid
+ return SCALE_TYPE_QUARTER;
+ default:
+ return SCALE_TYPE_ONE;
+ }
+ }
+
+ @Override
+ public void draw(final Canvas canvas) {
+ super.draw(canvas);
+
+ final Rect bounds = getBounds();
+ if (!isVisible() || bounds.isEmpty()) {
+ return;
+ }
+
+ // Draw horizontal and vertical dividers.
+ switch (mCount) {
+ case 1:
+ // 1 bitmap: passthrough
+ break;
+ case 2:
+ // 2 bitmaps split vertically
+ canvas.drawLine(bounds.centerX(), bounds.top, bounds.centerX(), bounds.bottom,
+ mPaint);
+ break;
+ case 3:
+ // 1st is tall on the left, 2nd/3rd stacked vertically on the right
+ canvas.drawLine(bounds.centerX(), bounds.top, bounds.centerX(), bounds.bottom,
+ mPaint);
+ canvas.drawLine(bounds.centerX(), bounds.centerY(), bounds.right, bounds.centerY(),
+ mPaint);
+ break;
+ case 4:
+ // 4 bitmaps in a 2x2 grid
+ canvas.drawLine(bounds.centerX(), bounds.top, bounds.centerX(), bounds.bottom,
+ mPaint);
+ canvas.drawLine(bounds.left, bounds.centerY(), bounds.right, bounds.centerY(),
+ mPaint);
+ break;
+ }
+ }
+
+ @Override
+ public void setAlpha(final int alpha) {
+ super.setAlpha(alpha);
+ final int old = mPaint.getAlpha();
+ mPaint.setAlpha(alpha);
+ if (alpha != old) {
+ invalidateSelf();
+ }
+ }
+
+ @Override
+ public void setColorFilter(final ColorFilter cf) {
+ super.setColorFilter(cf);
+ mPaint.setColorFilter(cf);
+ invalidateSelf();
+ }
+
+ public void setBitmapCache(final BitmapCache cache) {
+ mCache = cache;
+ }
+
+ public void setContactResolver(final ContactResolver contactResolver) {
+ mContactResolver = contactResolver;
+ }
+}
diff --git a/src/com/android/mail/bitmap/ContactRequest.java b/src/com/android/mail/bitmap/ContactRequest.java
new file mode 100644
index 0000000..b0bd2a0
--- /dev/null
+++ b/src/com/android/mail/bitmap/ContactRequest.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.mail.bitmap;
+
+import android.content.res.AssetFileDescriptor;
+import android.text.TextUtils;
+
+import com.android.bitmap.DecodeTask;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A request object for contact images. ContactRequests have a destination because multiple
+ * ContactRequests can share the same decoded data.
+ */
+public class ContactRequest implements DecodeTask.Request {
+
+ private final String mName;
+ private final String mEmail;
+
+ public byte[] bytes;
+
+ public ContactRequest(final String name, final String email) {
+ mName = name;
+ mEmail = normalizeEmail(email);
+ }
+
+ private String normalizeEmail(final String email) {
+ if (TextUtils.isEmpty(email)) {
+ throw new IllegalArgumentException("Email must not be empty.");
+ }
+ // todo: b/10258788
+ return email;
+ }
+
+ @Override
+ public boolean equals(final Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ final ContactRequest that = (ContactRequest) o;
+
+ // Only count email, so we can pull results out of the cache that are from other contact
+ // requests.
+ //noinspection RedundantIfStatement
+ if (mEmail != null ? !mEmail.equals(that.mEmail) : that.mEmail != null) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ // Only count email, so we can pull results out of the cache that are from other contact
+ // requests.
+ return mEmail != null ? mEmail.hashCode() : 0;
+ }
+
+ @Override
+ public String toString() {
+ return "[" + super.toString() + " mName=" + mName + " mEmail=" + mEmail + "]";
+ }
+
+ @Override
+ public AssetFileDescriptor createFd() throws IOException {
+ return null;
+ }
+
+ @Override
+ public InputStream createInputStream() throws IOException {
+ return new ByteArrayInputStream(bytes);
+ }
+
+ @Override
+ public boolean hasOrientationExif() throws IOException {
+ return false;
+ }
+
+ public String getEmail() {
+ return mEmail;
+ }
+
+ public String getDisplayName() {
+ return !TextUtils.isEmpty(mName) ? mName : mEmail;
+ }
+
+ /**
+ * This ContactRequest wrapper provides implementations of equals() and hashcode() that
+ * include the destination. We need to put multiple ContactRequests in a set,
+ * but its implementations of equals() and hashcode() don't include the destination.
+ */
+ public static class ContactRequestHolder {
+
+ public final ContactRequest contactRequest;
+ public final ContactDrawable destination;
+
+ public ContactRequestHolder(final ContactRequest contactRequest,
+ final ContactDrawable destination) {
+ this.contactRequest = contactRequest;
+ this.destination = destination;
+ }
+
+ @Override
+ public boolean equals(final Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ final ContactRequestHolder that = (ContactRequestHolder) o;
+
+ if (contactRequest != null ? !contactRequest.equals(that.contactRequest)
+ : that.contactRequest != null) {
+ return false;
+ }
+ //noinspection RedundantIfStatement
+ if (destination != null ? !destination.equals(that.destination)
+ : that.destination != null) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = contactRequest != null ? contactRequest.hashCode() : 0;
+ result = 31 * result + (destination != null ? destination.hashCode() : 0);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return contactRequest.toString();
+ }
+
+ public String getEmail() {
+ return contactRequest.getEmail();
+ }
+
+ public String getDisplayName() {
+ return contactRequest.getDisplayName();
+ }
+ }
+}
diff --git a/src/com/android/mail/bitmap/ContactResolver.java b/src/com/android/mail/bitmap/ContactResolver.java
new file mode 100644
index 0000000..b3d1fd5
--- /dev/null
+++ b/src/com/android/mail/bitmap/ContactResolver.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2013 Google Inc.
+ * Licensed to The Android Open Source Project.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.mail.bitmap;
+
+import android.content.ContentResolver;
+import android.os.AsyncTask;
+import android.os.AsyncTask.Status;
+import android.os.Handler;
+
+import com.android.bitmap.BitmapCache;
+import com.android.bitmap.DecodeTask;
+import com.android.bitmap.ReusableBitmap;
+import com.android.ex.photo.util.Trace;
+import com.android.mail.ContactInfo;
+import com.android.mail.SenderInfoLoader;
+import com.android.mail.bitmap.ContactRequest.ContactRequestHolder;
+import com.android.mail.utils.LogTag;
+import com.android.mail.utils.LogUtils;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Batches up ContactRequests so we can efficiently query the contacts provider. Kicks off a
+ * ContactResolverTask to query for contact images in the background.
+ */
+public class ContactResolver implements Runnable {
+
+ private static final String TAG = LogTag.getLogTag();
+
+ private final ContentResolver mResolver;
+ private final BitmapCache mCache;
+ /** Insertion ordered set allows us to work from the top down. */
+ private final LinkedHashSet<ContactRequestHolder> mBatch;
+
+ private final Handler mHandler = new Handler();
+ private ContactResolverTask mTask;
+
+
+ /** Size 1 pool mostly to make systrace output traces on one line. */
+ private static final Executor SMALL_POOL_EXECUTOR = new ThreadPoolExecutor(1, 1,
+ 1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+ private static final Executor EXECUTOR = SMALL_POOL_EXECUTOR;
+
+ public ContactResolver(final ContentResolver resolver, final BitmapCache cache) {
+ mResolver = resolver;
+ mCache = cache;
+ mBatch = new LinkedHashSet<ContactRequestHolder>();
+ }
+
+ @Override
+ public void run() {
+ // Start to process a new batch.
+ if (mBatch.isEmpty()) {
+ return;
+ }
+
+ if (mTask != null && mTask.getStatus() == Status.RUNNING) {
+ LogUtils.d(TAG, "ContactResolver << batch skip");
+ return;
+ }
+
+ Trace.beginSection("ContactResolver run");
+ LogUtils.d(TAG, "ContactResolver >> batch start");
+
+ // Make a copy of the batch.
+ LinkedHashSet<ContactRequestHolder> batch = new LinkedHashSet<ContactRequestHolder>(mBatch);
+
+ if (mTask != null) {
+ mTask.cancel(true);
+ }
+
+ mTask = new ContactResolverTask(batch, mResolver, mCache, this);
+ mTask.executeOnExecutor(EXECUTOR);
+ Trace.endSection();
+ }
+
+ public void add(final ContactRequest request, final ContactDrawable drawable) {
+ mBatch.add(new ContactRequestHolder(request, drawable));
+ notifyBatchReady();
+ }
+
+ public void remove(final ContactRequest request, final ContactDrawable drawable) {
+ mBatch.remove(new ContactRequestHolder(request, drawable));
+ }
+
+ /**
+ * A layout pass traverses the whole tree during a single iteration of the event loop. That
+ * means that every ContactDrawable on the screen will add its ContactRequest to the batch in
+ * a single iteration of the event loop.
+ *
+ * <p/>
+ * We take advantage of this by posting a Runnable (happens to be this object) at the end of
+ * the event queue. Every time something is added to the batch as part of the same layout pass,
+ * the Runnable is moved to the back of the queue. When the next layout pass occurs,
+ * it is placed in the event loop behind this Runnable. That allows us to process the batch
+ * that was added previously.
+ */
+ private void notifyBatchReady() {
+ LogUtils.d(TAG, "ContactResolver > batch %d", mBatch.size());
+ mHandler.removeCallbacks(this);
+ mHandler.post(this);
+ }
+
+ /**
+ * This is not a very traditional AsyncTask, in the sense that we do not care about what gets
+ * returned in doInBackground(). Instead, we signal traditional "return values" through
+ * publishProgress().
+ *
+ * <p/>
+ * The reason we do this is because this task is responsible for decoding an entire batch of
+ * ContactRequests. But, we do not want to have to wait to decode all of them before updating
+ * any views. So we must do all the work in doInBackground(),
+ * but upon finishing each individual task, we need to jump out to the UI thread and update
+ * that view.
+ */
+ private static class ContactResolverTask extends AsyncTask<Void, Result, Void> {
+
+ private final Set<ContactRequestHolder> mContactRequests;
+ private final ContentResolver mResolver;
+ private final BitmapCache mCache;
+ private final ContactResolver mCallback;
+
+ public ContactResolverTask(final Set<ContactRequestHolder> contactRequests,
+ final ContentResolver resolver, final BitmapCache cache,
+ final ContactResolver callback) {
+ mContactRequests = contactRequests;
+ mResolver = resolver;
+ mCache = cache;
+ mCallback = callback;
+ }
+
+ @Override
+ protected Void doInBackground(final Void... params) {
+ Trace.beginSection("set up");
+ final Set<String> emails = new HashSet<String>(mContactRequests.size());
+ for (ContactRequestHolder request : mContactRequests) {
+ final String email = request.getEmail();
+ emails.add(email);
+ }
+ Trace.endSection();
+
+ Trace.beginSection("load contact photo bytes");
+ // Query the contacts provider for the current batch of emails.
+ ImmutableMap<String, ContactInfo> contactInfos = SenderInfoLoader
+ .loadContactPhotos(mResolver, emails, false /* decodeBitmaps */);
+ Trace.endSection();
+
+ for (ContactRequestHolder request : mContactRequests) {
+ Trace.beginSection("decode");
+ final String email = request.getEmail();
+ if (contactInfos == null) {
+ // Query failed.
+ LogUtils.d(TAG, "ContactResolver -- failed %s", email);
+ publishProgress(new Result(request, null));
+ Trace.endSection();
+ continue;
+ }
+
+ final ContactInfo contactInfo = contactInfos.get(email);
+ if (contactInfo == null) {
+ // Request skipped. Try again next batch.
+ LogUtils.d(TAG, "ContactResolver = skipped %s", email);
+ Trace.endSection();
+ continue;
+ }
+
+ // Query attempted.
+ final byte[] photo = contactInfo.photoBytes;
+ if (photo == null) {
+ // No photo bytes found.
+ LogUtils.d(TAG, "ContactResolver -- failed %s", email);
+ publishProgress(new Result(request, null));
+ Trace.endSection();
+ continue;
+ }
+
+ // Query succeeded. Photo bytes found.
+ request.contactRequest.bytes = photo;
+
+ // Start decode.
+ LogUtils.d(TAG, "ContactResolver ++ found %s", email);
+ final ReusableBitmap result;
+ final int width = mCache.getDecodeWidth();
+ final int height = mCache.getDecodeHeight();
+ // Synchronously decode the photo bytes. We are already in a background
+ // thread, and we want decodes to finish in order. The decodes are blazing
+ // fast so we don't need to kick off multiple threads.
+ result = new DecodeTask(request.contactRequest, width, height, width, height, null,
+ mCache).decode();
+ request.contactRequest.bytes = null;
+
+ // Decode success.
+ publishProgress(new Result(request, result));
+ Trace.endSection();
+ }
+
+ return null;
+ }
+
+ /**
+ * We use progress updates to jump to the UI thread so we can decode the batch
+ * incrementally.
+ */
+ @Override
+ protected void onProgressUpdate(final Result... values) {
+ final ContactRequestHolder request = values[0].request;
+ final ReusableBitmap bitmap = values[0].bitmap;
+
+ // DecodeTask does not add null results to the cache.
+ if (bitmap == null) {
+ // Cache null result.
+ mCache.put(request.contactRequest, null);
+ }
+
+ request.destination.onDecodeComplete(request.contactRequest, bitmap);
+ }
+
+ @Override
+ protected void onPostExecute(final Void aVoid) {
+ // Batch completed. Start next batch.
+ mCallback.notifyBatchReady();
+ }
+ }
+
+ /**
+ * Wrapper for the ContactRequest and its decoded bitmap. This class is used to pass results
+ * to onProgressUpdate().
+ */
+ private static class Result {
+ public final ContactRequestHolder request;
+ public final ReusableBitmap bitmap;
+
+ private Result(final ContactRequestHolder request, final ReusableBitmap bitmap) {
+ this.request = request;
+ this.bitmap = bitmap;
+ }
+ }
+}
diff --git a/src/com/android/mail/bitmap/FlipDrawable.java b/src/com/android/mail/bitmap/FlipDrawable.java
new file mode 100644
index 0000000..6cc7b26
--- /dev/null
+++ b/src/com/android/mail/bitmap/FlipDrawable.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.mail.bitmap;
+
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+
+import com.android.mail.utils.LogUtils;
+
+/**
+ * A drawable that wraps two other drawables and allows flipping between them. The flipping
+ * animation is a 2D rotation around the y axis.
+ *
+ * <p/>
+ * The 3 durations are: (best viewed in documentation form)
+ * <pre>
+ * <pre>[_][]|[][_]<post>
+ * | | |
+ * V V V
+ * <pre>< flip ><post>
+ * </pre>
+ */
+public class FlipDrawable extends Drawable implements Drawable.Callback {
+
+ /**
+ * The inner drawables.
+ */
+ protected final Drawable mFront;
+ protected final Drawable mBack;
+
+ protected final int mFlipDurationMs;
+ protected final int mPreFlipDurationMs;
+ protected final int mPostFlipDurationMs;
+ private final ValueAnimator mFlipAnimator;
+
+ private static final float END_VALUE = 2f;
+
+ /**
+ * From 0f to END_VALUE. Determines the flip progress between mFront and mBack. 0f means
+ * mFront is fully shown, while END_VALUE means mBack is fully shown.
+ */
+ private float mFlipFraction = 0f;
+
+ /**
+ * True if flipping towards front, false if flipping towards back.
+ */
+ private boolean mFlipToSide = true;
+
+ /**
+ * Create a new FlipDrawable. The front is fully shown by default.
+ *
+ * <p/>
+ * The 3 durations are: (best viewed in documentation form)
+ * <pre>
+ * <pre>[_][]|[][_]<post>
+ * | | |
+ * V V V
+ * <pre>< flip ><post>
+ * </pre>
+ *
+ * @param front The front drawable.
+ * @param back The back drawable.
+ * @param flipDurationMs The duration of the actual flip. This duration includes both
+ * animating away one side and showing the other.
+ * @param preFlipDurationMs The duration before the actual flip begins. Subclasses can use this
+ * to add flourish.
+ * @param postFlipDurationMs The duration after the actual flip begins. Subclasses can use this
+ * to add flourish.
+ */
+ public FlipDrawable(final Drawable front, final Drawable back, final int flipDurationMs,
+ final int preFlipDurationMs, final int postFlipDurationMs) {
+ if (front == null || back == null) {
+ throw new IllegalArgumentException("Front and back drawables must not be null.");
+ }
+ mFront = front;
+ mBack = back;
+
+ mFront.setCallback(this);
+ mBack.setCallback(this);
+
+ mFlipDurationMs = flipDurationMs;
+ mPreFlipDurationMs = preFlipDurationMs;
+ mPostFlipDurationMs = postFlipDurationMs;
+
+ mFlipAnimator = ValueAnimator.ofFloat(0f, END_VALUE)
+ .setDuration(mPreFlipDurationMs + mFlipDurationMs + mPostFlipDurationMs);
+ mFlipAnimator.addUpdateListener(new AnimatorUpdateListener() {
+ @Override
+ public void onAnimationUpdate(final ValueAnimator animation) {
+ final float old = mFlipFraction;
+ //noinspection ConstantConditions
+ mFlipFraction = (Float) animation.getAnimatedValue();
+ if (old != mFlipFraction) {
+ invalidateSelf();
+ }
+ }
+ });
+
+ reset(true);
+ }
+
+ @Override
+ protected void onBoundsChange(final Rect bounds) {
+ super.onBoundsChange(bounds);
+ if (bounds.isEmpty()) {
+ mFront.setBounds(0, 0, 0, 0);
+ mBack.setBounds(0, 0, 0, 0);
+ } else {
+ mFront.setBounds(bounds);
+ mBack.setBounds(bounds);
+ }
+ }
+
+ @Override
+ public void draw(final Canvas canvas) {
+ final Rect bounds = getBounds();
+ if (!isVisible() || bounds.isEmpty()) {
+ return;
+ }
+
+ final Drawable inner = getSideShown() /* == front */ ? mFront : mBack;
+
+ final float totalDurationMs = mPreFlipDurationMs + mFlipDurationMs + mPostFlipDurationMs;
+
+ final float scaleX;
+ if (mFlipFraction / 2 <= mPreFlipDurationMs / totalDurationMs) {
+ // During pre-flip.
+ scaleX = 1;
+ } else if (mFlipFraction / 2 >= (totalDurationMs - mPostFlipDurationMs) / totalDurationMs) {
+ // During post-flip.
+ scaleX = 1;
+ } else {
+ // During flip.
+ final float flipFraction = mFlipFraction / 2;
+ final float flipMiddle = (mPreFlipDurationMs / totalDurationMs
+ + (totalDurationMs - mPostFlipDurationMs) / totalDurationMs) / 2;
+ final float distFraction = Math.abs(flipFraction - flipMiddle);
+ final float multiplier = 1 / (flipMiddle - (mPreFlipDurationMs / totalDurationMs));
+ scaleX = distFraction * multiplier;
+ }
+
+ canvas.save();
+ // The flip is a simple 1 dimensional scale.
+ canvas.scale(scaleX, 1, bounds.exactCenterX(), bounds.exactCenterY());
+ inner.draw(canvas);
+ canvas.restore();
+ }
+
+ @Override
+ public void setAlpha(final int alpha) {
+ mFront.setAlpha(alpha);
+ mBack.setAlpha(alpha);
+ }
+
+ @Override
+ public void setColorFilter(final ColorFilter cf) {
+ mFront.setColorFilter(cf);
+ mBack.setColorFilter(cf);
+ }
+
+ @Override
+ public int getOpacity() {
+ return resolveOpacity(mFront.getOpacity(), mBack.getOpacity());
+ }
+
+ @Override
+ protected boolean onLevelChange(final int level) {
+ return mFront.setLevel(level) || mBack.setLevel(level);
+ }
+
+ @Override
+ public void invalidateDrawable(final Drawable who) {
+ invalidateSelf();
+ }
+
+ @Override
+ public void scheduleDrawable(final Drawable who, final Runnable what, final long when) {
+ scheduleSelf(what, when);
+ }
+
+ @Override
+ public void unscheduleDrawable(final Drawable who, final Runnable what) {
+ unscheduleSelf(what);
+ }
+
+ /**
+ * Stop animating the flip and reset to one side.
+ * @param side Pass true if reset to front, false if reset to back.
+ */
+ public void reset(final boolean side) {
+ final float old = mFlipFraction;
+ mFlipAnimator.cancel();
+ mFlipFraction = side ? 0f : 2f;
+ mFlipToSide = side;
+ if (mFlipFraction != old) {
+ invalidateSelf();
+ }
+ }
+
+ /**
+ * Returns true if the front is shown. Returns false if the back is shown.
+ */
+ public boolean getSideShown() {
+ final float totalDurationMs = mPreFlipDurationMs + mFlipDurationMs + mPostFlipDurationMs;
+ final float middleFraction = (mPreFlipDurationMs / totalDurationMs
+ + (totalDurationMs - mPostFlipDurationMs) / totalDurationMs) / 2;
+ return mFlipFraction / 2 < middleFraction;
+ }
+
+ /**
+ * Returns true if the front is being flipped towards. Returns false if the back is being
+ * flipped towards.
+ */
+ public boolean getSideFlippingTowards() {
+ return mFlipToSide;
+ }
+
+ /**
+ * Starts an animated flip to the other side. If a flip animation is currently started,
+ * it will be reversed.
+ */
+ public void flip() {
+ mFlipToSide = !mFlipToSide;
+ if (mFlipAnimator.isStarted()) {
+ mFlipAnimator.reverse();
+ } else {
+ if (!mFlipToSide /* front to back */) {
+ mFlipAnimator.start();
+ } else /* back to front */ {
+ mFlipAnimator.reverse();
+ }
+ }
+ }
+
+ /**
+ * Start an animated flip to a side. This works regardless of whether a flip animation is
+ * currently started.
+ * @param side Pass true if flip to front, false if flip to back.
+ */
+ public void flipTo(final boolean side) {
+ if (mFlipToSide != side) {
+ flip();
+ }
+ }
+
+ /**
+ * Returns whether flipping is in progress.
+ */
+ public boolean isFlipping() {
+ return mFlipAnimator.isStarted();
+ }
+}
diff --git a/src/com/android/mail/browse/ConversationItemView.java b/src/com/android/mail/browse/ConversationItemView.java
index 26c2241..06613e3 100644
--- a/src/com/android/mail/browse/ConversationItemView.java
+++ b/src/com/android/mail/browse/ConversationItemView.java
@@ -18,8 +18,6 @@
package com.android.mail.browse;
import android.animation.Animator;
-import android.animation.Animator.AnimatorListener;
-import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.content.ClipData;
@@ -31,7 +29,6 @@
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
-import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Rect;
@@ -60,7 +57,6 @@
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.animation.DecelerateInterpolator;
-import android.view.animation.LinearInterpolator;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.TextView;
@@ -72,11 +68,10 @@
import com.android.mail.analytics.Analytics;
import com.android.mail.bitmap.AttachmentDrawable;
import com.android.mail.bitmap.AttachmentGridDrawable;
+import com.android.mail.bitmap.ContactCheckableGridDrawable;
+import com.android.mail.bitmap.ContactDrawable;
import com.android.mail.browse.ConversationItemViewModel.SenderFragment;
import com.android.mail.perf.Timer;
-import com.android.mail.photomanager.ContactPhotoManager;
-import com.android.mail.photomanager.ContactPhotoManager.ContactIdentifier;
-import com.android.mail.photomanager.PhotoManager.PhotoIdentifier;
import com.android.mail.providers.Address;
import com.android.mail.providers.Attachment;
import com.android.mail.providers.Conversation;
@@ -87,9 +82,9 @@
import com.android.mail.providers.UIProvider.ConversationListIcon;
import com.android.mail.providers.UIProvider.FolderType;
import com.android.mail.ui.AnimatedAdapter;
-import com.android.mail.ui.AnimatedAdapter.ConversationListListener;
import com.android.mail.ui.ControllableActivity;
import com.android.mail.ui.ConversationSelectionSet;
+import com.android.mail.ui.ConversationSetObserver;
import com.android.mail.ui.DividedImageCanvas;
import com.android.mail.ui.DividedImageCanvas.InvalidateCallback;
import com.android.mail.ui.FolderDisplayer;
@@ -102,13 +97,12 @@
import com.android.mail.utils.LogUtils;
import com.android.mail.utils.Utils;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import java.util.ArrayList;
-import java.util.List;
public class ConversationItemView extends View
- implements SwipeableItemView, ToggleableItem, InvalidateCallback, OnScrollListener {
+ implements SwipeableItemView, ToggleableItem, InvalidateCallback, OnScrollListener,
+ ConversationSetObserver {
// Timer.
private static int sLayoutCount = 0;
@@ -125,7 +119,6 @@
// Static bitmaps.
private static Bitmap STAR_OFF;
private static Bitmap STAR_ON;
- private static Bitmap CHECK;
private static Bitmap ATTACHMENT;
private static Bitmap ONLY_TO_ME;
private static Bitmap TO_ME_AND_OTHERS;
@@ -201,15 +194,12 @@
private float mAnimatedHeightFraction = 1.0f;
private final String mAccount;
private ControllableActivity mActivity;
- private ConversationListListener mConversationListListener;
private final TextView mSubjectTextView;
private final TextView mSendersTextView;
private int mGadgetMode;
private boolean mAttachmentPreviewsEnabled;
private boolean mParallaxSpeedAlternative;
private boolean mParallaxDirectionAlternative;
- private final DividedImageCanvas mContactImagesHolder;
- private static ContactPhotoManager sContactPhotoManager;
private static int sFoldersLeftPadding;
private static TextAppearanceSpan sSubjectTextUnreadSpan;
@@ -219,19 +209,9 @@
private static int sScrollSlop;
private static CharacterStyle sActivatedTextSpan;
+ private final ContactCheckableGridDrawable mSendersImageView;
private final AttachmentGridDrawable mAttachmentsView;
- private final Matrix mPhotoFlipMatrix = new Matrix();
- private final Matrix mCheckMatrix = new Matrix();
-
- private final CabAnimator mPhotoFlipAnimator;
-
- /**
- * The conversation id, if this conversation was selected the last time we were in a selection
- * mode. This is reset after any animations complete upon exiting the selection mode.
- */
- private long mLastSelectedId = -1;
-
/** The resource id of the color to use to override the background. */
private int mBackgroundOverrideResId = -1;
/** The bitmap to use, or <code>null</code> for the default */
@@ -259,19 +239,6 @@
sCheckBackgroundPaint.setColor(Color.GRAY);
}
- public static void setScrollStateChanged(final int scrollState) {
- if (sContactPhotoManager == null) {
- return;
- }
- final boolean flinging = scrollState == OnScrollListener.SCROLL_STATE_FLING;
-
- if (flinging) {
- sContactPhotoManager.pause();
- } else {
- sContactPhotoManager.resume();
- }
- }
-
/**
* Handles displaying folders in a conversation header view.
*/
@@ -422,7 +389,6 @@
// Initialize static bitmaps.
STAR_OFF = BitmapFactory.decodeResource(res, R.drawable.ic_btn_star_off);
STAR_ON = BitmapFactory.decodeResource(res, R.drawable.ic_btn_star_on);
- CHECK = BitmapFactory.decodeResource(res, R.drawable.ic_avatar_check);
ATTACHMENT = BitmapFactory.decodeResource(res, R.drawable.ic_attachment_holo_light);
ONLY_TO_ME = BitmapFactory.decodeResource(res, R.drawable.ic_email_caret_double);
TO_ME_AND_OTHERS = BitmapFactory.decodeResource(res, R.drawable.ic_email_caret_single);
@@ -469,24 +435,10 @@
sOverflowCountFormat = res.getString(string.ap_overflow_format);
sScrollSlop = res.getInteger(R.integer.swipeScrollSlop);
sFoldersLeftPadding = res.getDimensionPixelOffset(R.dimen.folders_left_padding);
- sContactPhotoManager = ContactPhotoManager.createContactPhotoManager(context);
sOverflowCountMax = res.getInteger(integer.ap_overflow_max_count);
- sCabAnimationDuration =
- res.getInteger(R.integer.conv_item_view_cab_anim_duration);
+ sCabAnimationDuration = res.getInteger(R.integer.conv_item_view_cab_anim_duration);
}
- mPhotoFlipAnimator = new CabAnimator("photoFlipFraction", 0, 2,
- sCabAnimationDuration) {
- @Override
- public void invalidateArea() {
- final int left = mCoordinates.contactImagesX;
- final int right = left + mContactImagesHolder.getWidth();
- final int top = mCoordinates.contactImagesY;
- final int bottom = top + mContactImagesHolder.getHeight();
- invalidate(left, top, right, bottom);
- }
- };
-
mSendersTextView = new TextView(mContext);
mSendersTextView.setIncludeFontPadding(false);
@@ -494,27 +446,16 @@
mSubjectTextView.setEllipsize(TextUtils.TruncateAt.END);
mSubjectTextView.setIncludeFontPadding(false);
- mContactImagesHolder = new DividedImageCanvas(context, new InvalidateCallback() {
- @Override
- public void invalidate() {
- if (mCoordinates == null) {
- return;
- }
- ConversationItemView.this.invalidate(mCoordinates.contactImagesX,
- mCoordinates.contactImagesY,
- mCoordinates.contactImagesX + mCoordinates.contactImagesWidth,
- mCoordinates.contactImagesY + mCoordinates.contactImagesHeight);
- }
- });
-
mAttachmentsView = new AttachmentGridDrawable(res, PLACEHOLDER, PROGRESS_BAR);
mAttachmentsView.setCallback(this);
+ mSendersImageView = new ContactCheckableGridDrawable(res, sCabAnimationDuration);
+ mSendersImageView.setCallback(this);
+
Utils.traceEndSection();
}
public void bind(final Conversation conversation, final ControllableActivity activity,
- final ConversationListListener conversationListListener,
final ConversationSelectionSet set, final Folder folder,
final int checkboxOrSenderImage, final boolean showAttachmentPreviews,
final boolean parallaxSpeedAlternative, final boolean parallaxDirectionAlternative,
@@ -522,31 +463,28 @@
final AnimatedAdapter adapter) {
Utils.traceBeginSection("CIVC.bind");
bind(ConversationItemViewModel.forConversation(mAccount, conversation), activity,
- conversationListListener, null /* conversationItemAreaClickListener */, set, folder,
- checkboxOrSenderImage, showAttachmentPreviews, parallaxSpeedAlternative,
- parallaxDirectionAlternative, swipeEnabled, priorityArrowEnabled, adapter,
- -1 /* backgroundOverrideResId */,
- null /* photoBitmap */);
+ null /* conversationItemAreaClickListener */,
+ set, folder, checkboxOrSenderImage, showAttachmentPreviews,
+ parallaxSpeedAlternative, parallaxDirectionAlternative, swipeEnabled,
+ priorityArrowEnabled, adapter, -1 /* backgroundOverrideResId */, null /* photoBitmap */);
Utils.traceEndSection();
}
public void bindAd(final ConversationItemViewModel conversationItemViewModel,
final ControllableActivity activity,
- final ConversationListListener conversationListListener,
final ConversationItemAreaClickListener conversationItemAreaClickListener,
final Folder folder, final int checkboxOrSenderImage, final AnimatedAdapter adapter,
final int backgroundOverrideResId, final Bitmap photoBitmap) {
Utils.traceBeginSection("CIVC.bindAd");
- bind(conversationItemViewModel, activity, conversationListListener,
- conversationItemAreaClickListener, null /* set */, folder, checkboxOrSenderImage,
- false /* attachment previews */, false /* parallax */, false /* parallax */,
- true /* swipeEnabled */, false /* priorityArrowEnabled */, adapter,
- backgroundOverrideResId, photoBitmap);
+ bind(conversationItemViewModel, activity, conversationItemAreaClickListener, null /* set */,
+ folder, checkboxOrSenderImage, false /* attachment previews */,
+ false /* parallax */, false /* parallax */, true /* swipeEnabled */,
+ false /* priorityArrowEnabled */,
+ adapter, backgroundOverrideResId, photoBitmap);
Utils.traceEndSection();
}
private void bind(final ConversationItemViewModel header, final ControllableActivity activity,
- final ConversationListListener conversationListListener,
final ConversationItemAreaClickListener conversationItemAreaClickListener,
final ConversationSelectionSet set, final Folder folder,
final int checkboxOrSenderImage, final boolean showAttachmentPreviews,
@@ -558,28 +496,25 @@
mConversationItemAreaClickListener = conversationItemAreaClickListener;
if (mHeader != null) {
+ Utils.traceBeginSection("unbind");
+ final boolean newlyBound = header.conversation.id != mHeader.conversation.id;
// If this was previously bound to a different conversation, remove any contact photo
// manager requests.
- if (header.conversation.id != mHeader.conversation.id ||
- (mHeader.displayableSenderNames != null && !mHeader.displayableSenderNames
- .equals(header.displayableSenderNames))) {
- ArrayList<String> divisionIds = mContactImagesHolder.getDivisionIds();
- if (divisionIds != null) {
- mContactImagesHolder.reset();
- for (int pos = 0; pos < divisionIds.size(); pos++) {
- sContactPhotoManager.removePhoto(ContactPhotoManager.generateHash(
- mContactImagesHolder, pos, divisionIds.get(pos)));
- }
+ if (newlyBound || (mHeader.displayableSenderNames != null && !mHeader
+ .displayableSenderNames.equals(
+ header.displayableSenderNames))) {
+ for (int i = 0; i < mSendersImageView.getCount(); i++) {
+ mSendersImageView.getOrCreateDrawable(i).unbind();
}
+ mSendersImageView.setCount(0);
}
// If this was previously bound to a different conversation,
// remove any attachment preview manager requests.
- if (header.conversation.id != mHeader.conversation.id
- || header.conversation.attachmentPreviewsCount
- != mHeader.conversation.attachmentPreviewsCount
- || !header.conversation.getAttachmentPreviewUris()
- .equals(mHeader.conversation.getAttachmentPreviewUris())) {
+ if (newlyBound || header.conversation.attachmentPreviewsCount
+ != mHeader.conversation.attachmentPreviewsCount || !header.conversation
+ .getAttachmentPreviewUris().equals(
+ mHeader.conversation.getAttachmentPreviewUris())) {
// unbind the attachments view (releasing bitmap references)
// (this also cancels all async tasks)
@@ -590,22 +525,29 @@
mAttachmentsView.setCount(0);
}
- if (header.conversation.id != mHeader.conversation.id) {
+ if (newlyBound) {
// Stop the photo flip animation
- mPhotoFlipAnimator.stopAnimation();
+ final boolean showSenders = !isSelected();
+ mSendersImageView.reset(showSenders);
}
+ Utils.traceEndSection();
}
mCoordinates = null;
mHeader = header;
mActivity = activity;
- mConversationListListener = conversationListListener;
mSelectedConversationSet = set;
+ mSelectedConversationSet.addObserver(this);
mDisplayedFolder = folder;
mStarEnabled = folder != null && !folder.isTrash();
mSwipeEnabled = swipeEnabled;
mAdapter = adapter;
- mAttachmentsView.setBitmapCache(mAdapter.getBitmapCache());
- mAttachmentsView.setDecodeAggregator(mAdapter.getDecodeAggregator());
+
+ Utils.traceBeginSection("drawables");
+ mAttachmentsView.setBitmapCache(mAdapter.getAttachmentPreviewsCache());
+ mAttachmentsView.setDecodeAggregator(mAdapter.getAttachmentPreviewsDecodeAggregator());
+ mSendersImageView.setBitmapCache(mAdapter.getSendersImagesCache());
+ mSendersImageView.setContactResolver(mAdapter.getContactResolver());
+ Utils.traceEndSection();
if (checkboxOrSenderImage == ConversationListIcon.SENDER_IMAGE) {
mGadgetMode = ConversationItemViewCoordinates.GADGET_CONTACT_PHOTO;
@@ -617,12 +559,14 @@
mParallaxSpeedAlternative = parallaxSpeedAlternative;
mParallaxDirectionAlternative = parallaxDirectionAlternative;
+ Utils.traceBeginSection("folder displayer");
// Initialize folder displayer.
if (mHeader.folderDisplayer == null) {
mHeader.folderDisplayer = new ConversationItemFolderDisplayer(mContext);
} else {
mHeader.folderDisplayer.reset();
}
+ Utils.traceEndSection();
final int ignoreFolderType;
if (mDisplayedFolder.isInbox()) {
@@ -631,16 +575,21 @@
ignoreFolderType = -1;
}
+ Utils.traceBeginSection("load folders");
mHeader.folderDisplayer.loadConversationFolders(mHeader.conversation,
mDisplayedFolder.folderUri, ignoreFolderType);
+ Utils.traceEndSection();
if (mHeader.dateOverrideText == null) {
+ Utils.traceBeginSection("relative time");
mHeader.dateText = DateUtils.getRelativeTimeSpanString(mContext,
mHeader.conversation.dateMs);
+ Utils.traceEndSection();
} else {
mHeader.dateText = mHeader.dateOverrideText;
}
+ Utils.traceBeginSection("config setup");
mConfig = new ConversationItemViewCoordinates.Config()
.withGadget(mGadgetMode)
.withAttachmentPreviews(getAttachmentPreviewsMode());
@@ -653,6 +602,7 @@
if (mHeader.conversation.color != 0) {
mConfig.showColorBlock();
}
+
// Personal level.
mHeader.personalLevelBitmap = null;
if (true) { // TODO: hook this up to a setting
@@ -674,19 +624,23 @@
if (mHeader.personalLevelBitmap != null) {
mConfig.showPersonalIndicator();
}
+ Utils.traceEndSection();
+ Utils.traceBeginSection("overflow");
final int overflowCount = Math.min(getOverflowCount(), sOverflowCountMax);
mHeader.overflowText = (overflowCount > 0) ?
String.format(sOverflowCountFormat, overflowCount) : null;
-
mAttachmentsView.setOverflowText(mHeader.overflowText);
+ Utils.traceEndSection();
+ Utils.traceBeginSection("content description");
setContentDescription();
+ Utils.traceEndSection();
requestLayout();
}
@Override
- public void invalidateDrawable(Drawable who) {
+ public void invalidateDrawable(final Drawable who) {
boolean handled = false;
if (mCoordinates != null) {
if (mAttachmentsView.equals(who)) {
@@ -694,6 +648,11 @@
r.offset(mCoordinates.attachmentPreviewsX, mCoordinates.attachmentPreviewsY);
ConversationItemView.this.invalidate(r.left, r.top, r.right, r.bottom);
handled = true;
+ } else if (mSendersImageView.equals(who)) {
+ final Rect r = new Rect(who.getBounds());
+ r.offset(mCoordinates.contactImagesX, mCoordinates.contactImagesY);
+ ConversationItemView.this.invalidate(r.left, r.top, r.right, r.bottom);
+ handled = true;
}
}
if (!handled) {
@@ -767,12 +726,14 @@
Utils.traceEndSection();
// Subject.
+ Utils.traceBeginSection("subject");
createSubject(mHeader.unread);
if (!mHeader.isLayoutValid()) {
setContentDescription();
}
mHeader.validate();
+ Utils.traceEndSection();
pauseTimer(PERF_TAG_LAYOUT);
if (sTimer != null && ++sLayoutCount >= PERF_LAYOUT_ITERATIONS) {
@@ -922,34 +883,36 @@
// FIXME(ath): maybe move this to bind(). the only dependency on layout is on tile W/H, which
// is immutable.
private void loadSenderImages() {
- if (mGadgetMode == ConversationItemViewCoordinates.GADGET_CONTACT_PHOTO
- && mHeader.displayableSenderEmails != null
- && mHeader.displayableSenderEmails.size() > 0) {
- if (mCoordinates.contactImagesWidth <= 0 || mCoordinates.contactImagesHeight <= 0) {
- LogUtils.w(LOG_TAG,
- "Contact image width(%d) or height(%d) is 0 for mode: (%d).",
- mCoordinates.contactImagesWidth, mCoordinates.contactImagesHeight,
- mCoordinates.getMode());
- return;
- }
-
- int size = mHeader.displayableSenderEmails.size();
- final List<Object> keys = Lists.newArrayListWithCapacity(size);
- for (int i = 0; i < DividedImageCanvas.MAX_DIVISIONS && i < size; i++) {
- keys.add(mHeader.displayableSenderEmails.get(i));
- }
-
- mContactImagesHolder.setDimensions(mCoordinates.contactImagesWidth,
- mCoordinates.contactImagesHeight);
- mContactImagesHolder.setDivisionIds(keys);
- String emailAddress;
- for (int i = 0; i < DividedImageCanvas.MAX_DIVISIONS && i < size; i++) {
- emailAddress = mHeader.displayableSenderEmails.get(i);
- PhotoIdentifier photoIdentifier = new ContactIdentifier(
- mHeader.displayableSenderNames.get(i), emailAddress, i);
- sContactPhotoManager.loadThumbnail(photoIdentifier, mContactImagesHolder);
- }
+ if (mGadgetMode != ConversationItemViewCoordinates.GADGET_CONTACT_PHOTO
+ || mHeader.displayableSenderEmails == null
+ || mHeader.displayableSenderEmails.size() <= 0) {
+ return;
}
+ if (mCoordinates.contactImagesWidth <= 0 || mCoordinates.contactImagesHeight <= 0) {
+ LogUtils.w(LOG_TAG,
+ "Contact image width(%d) or height(%d) is 0 for mode: (%d).",
+ mCoordinates.contactImagesWidth, mCoordinates.contactImagesHeight,
+ mCoordinates.getMode());
+ return;
+ }
+
+ Utils.traceBeginSection("load sender images");
+ final int count = mHeader.displayableSenderEmails.size();
+
+ mSendersImageView.setCount(count);
+ mSendersImageView
+ .setBounds(0, 0, mCoordinates.contactImagesWidth, mCoordinates.contactImagesHeight);
+
+ for (int i = 0; i < DividedImageCanvas.MAX_DIVISIONS && i < count; i++) {
+ Utils.traceBeginSection("load single sender image");
+ final ContactDrawable drawable = mSendersImageView.getOrCreateDrawable(i);
+ drawable.setDecodeDimensions(mCoordinates.contactImagesWidth,
+ mCoordinates.contactImagesHeight);
+ drawable.bind(mHeader.displayableSenderNames.get(i),
+ mHeader.displayableSenderEmails.get(i));
+ Utils.traceEndSection();
+ }
+ Utils.traceEndSection();
}
private void loadAttachmentPreviews() {
@@ -1397,7 +1360,9 @@
// Contact photo
if (mGadgetMode == ConversationItemViewCoordinates.GADGET_CONTACT_PHOTO) {
canvas.save();
- drawContactImageArea(canvas);
+ Utils.traceBeginSection("draw senders image");
+ drawSendersImage(canvas);
+ Utils.traceEndSection();
canvas.restore();
}
@@ -1506,113 +1471,19 @@
Utils.traceEndSection();
}
- /**
- * Draws the contact images or check, in the correct animated state.
- */
- private void drawContactImageArea(final Canvas canvas) {
- if (isSelected()) {
- mLastSelectedId = mHeader.conversation.id;
-
- // Since this is selected, we draw the checkbox if the animation is not running, or if
- // it's running, and is past the half-way point
- if (mPhotoFlipAnimator.getValue() > 1 || !mPhotoFlipAnimator.isStarted()) {
- // Flash in the check
- drawCheckbox(canvas);
- } else {
- // Flip out the contact photo
- drawContactImages(canvas);
- }
- } else {
- if ((mConversationListListener.isExitingSelectionMode()
- && mLastSelectedId == mHeader.conversation.id)
- || mPhotoFlipAnimator.isStarted()) {
- // Animate back to the photo
- if (!mPhotoFlipAnimator.isStarted()) {
- mPhotoFlipAnimator.startAnimation(true /* reverse */);
- }
-
- if (mPhotoFlipAnimator.getValue() > 1) {
- // Flash out the check
- drawCheckbox(canvas);
- } else {
- // Flip in the contact photo
- drawContactImages(canvas);
- }
- } else {
- mLastSelectedId = -1; // We don't care anymore
- mPhotoFlipAnimator.stopAnimation(); // It's not running, but we want to reset state
-
- // Contact photos
- drawContactImages(canvas);
- }
+ private void drawSendersImage(final Canvas canvas) {
+ if (!mSendersImageView.isFlipping()) {
+ final boolean showSenders = !isSelected();
+ mSendersImageView.reset(showSenders);
}
- }
-
- private void drawContactImages(final Canvas canvas) {
- // mPhotoFlipFraction goes from 0 to 1
- final float value = mPhotoFlipAnimator.getValue();
-
- final float scale = 1f - value;
- final float xOffset = mContactImagesHolder.getWidth() * value / 2;
-
- mPhotoFlipMatrix.reset();
- mPhotoFlipMatrix.postScale(scale, 1);
-
- final float x = mCoordinates.contactImagesX + xOffset;
- final float y = mCoordinates.contactImagesY;
-
- canvas.translate(x, y);
-
+ canvas.translate(mCoordinates.contactImagesX, mCoordinates.contactImagesY);
if (mPhotoBitmap == null) {
- mContactImagesHolder.draw(canvas, mPhotoFlipMatrix);
+ mSendersImageView.draw(canvas);
} else {
canvas.drawBitmap(mPhotoBitmap, null, mPhotoRect, sPaint);
}
}
- private void drawCheckbox(final Canvas canvas) {
- // mPhotoFlipFraction goes from 1 to 2
-
- // Draw the background
- canvas.save();
- canvas.translate(mCoordinates.contactImagesX, mCoordinates.contactImagesY);
- canvas.drawRect(0, 0, mCoordinates.contactImagesWidth, mCoordinates.contactImagesHeight,
- sCheckBackgroundPaint);
- canvas.restore();
-
- final int x = mCoordinates.contactImagesX
- + (mCoordinates.contactImagesWidth - CHECK.getWidth()) / 2;
- final int y = mCoordinates.contactImagesY
- + (mCoordinates.contactImagesHeight - CHECK.getHeight()) / 2;
-
- final float value = mPhotoFlipAnimator.getValue();
- final float scale;
-
- if (!mPhotoFlipAnimator.isStarted()) {
- // We're not animating
- scale = 1;
- } else if (value < 1.9) {
- // 1.0 to 1.9 will scale 0 to 1
- scale = (value - 1f) / 0.9f;
- } else if (value < 1.95) {
- // 1.9 to 1.95 will scale 1 to 19/18
- scale = (value - 1f) / 0.9f;
- } else {
- // 1.95 to 2.0 will scale 19/18 to 1
- scale = (0.95f - (value - 1.95f)) / 0.9f;
- }
-
- final float xOffset = CHECK.getWidth() * (1f - scale) / 2f;
- final float yOffset = CHECK.getHeight() * (1f - scale) / 2f;
-
- mCheckMatrix.reset();
- mCheckMatrix.postScale(scale, scale);
-
- canvas.translate(x + xOffset, y + yOffset);
-
- canvas.drawBitmap(CHECK, mCheckMatrix, sPaint);
- }
-
private void drawAttachmentPreviews(Canvas canvas) {
canvas.translate(mCoordinates.attachmentPreviewsX, mCoordinates.attachmentPreviewsY);
final float fraction;
@@ -1691,13 +1562,13 @@
return toggleSelectedState(null);
}
- private boolean toggleSelectedState(String sourceOpt) {
+ private boolean toggleSelectedState(final String sourceOpt) {
if (mHeader != null && mHeader.conversation != null && mSelectedConversationSet != null) {
mSelected = !mSelected;
setSelected(mSelected);
- Conversation conv = mHeader.conversation;
+ final Conversation conv = mHeader.conversation;
// Set the list position of this item in the conversation
- SwipeableListView listView = getListView();
+ final SwipeableListView listView = getListView();
try {
conv.position = mSelected && listView != null ? listView.getPositionForView(this)
@@ -1716,9 +1587,8 @@
listView.commitDestructiveActions(true);
}
- final boolean reverse = !mSelected;
- mPhotoFlipAnimator.startAnimation(reverse);
- mPhotoFlipAnimator.invalidateArea();
+ final boolean front = !mSelected;
+ mSendersImageView.flipTo(front);
// We update the background after the checked state has changed
// now that we have a selected background asset. Setting the background
@@ -1732,6 +1602,17 @@
return false;
}
+ @Override
+ public void onSetEmpty() {
+ mSendersImageView.flipTo(true);
+ }
+
+ @Override
+ public void onSetPopulated(final ConversationSelectionSet set) { }
+
+ @Override
+ public void onSetChanged(final ConversationSelectionSet set) { }
+
/**
* Toggle the star on this view and update the conversation.
*/
@@ -2179,124 +2060,6 @@
return sScrollSlop;
}
- private abstract class CabAnimator {
- private ObjectAnimator mAnimator = null;
-
- private final String mPropertyName;
-
- private float mValue;
-
- private final float mStartValue;
- private final float mEndValue;
-
- private final long mDuration;
-
- private boolean mReversing = false;
-
- public CabAnimator(final String propertyName, final float startValue, final float endValue,
- final long duration) {
- mPropertyName = propertyName;
-
- mStartValue = startValue;
- mEndValue = endValue;
-
- mDuration = duration;
- }
-
- private ObjectAnimator createAnimator() {
- final ObjectAnimator animator = ObjectAnimator.ofFloat(ConversationItemView.this,
- mPropertyName, mStartValue, mEndValue);
- animator.setDuration(mDuration);
- animator.setInterpolator(new LinearInterpolator());
- animator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(final Animator animation) {
- invalidateArea();
- }
- });
- animator.addListener(mAnimatorListener);
- return animator;
- }
-
- private final AnimatorListener mAnimatorListener = new AnimatorListener() {
- @Override
- public void onAnimationStart(final Animator animation) {
- // Do nothing
- }
-
- @Override
- public void onAnimationEnd(final Animator animation) {
- if (mReversing) {
- mReversing = false;
- // We no longer want to track whether we were last selected,
- // since we no longer are selected
- mLastSelectedId = -1;
- }
- }
-
- @Override
- public void onAnimationCancel(final Animator animation) {
- // Do nothing
- }
-
- @Override
- public void onAnimationRepeat(final Animator animation) {
- // Do nothing
- }
- };
-
- public abstract void invalidateArea();
-
- public void setValue(final float fraction) {
- if (mValue == fraction) {
- return;
- }
- mValue = fraction;
- invalidateArea();
- }
-
- public float getValue() {
- return mValue;
- }
-
- /**
- * @param reverse <code>true</code> to animate in reverse
- */
- public void startAnimation(final boolean reverse) {
- if (mAnimator != null) {
- mAnimator.cancel();
- }
-
- mAnimator = createAnimator();
- mReversing = reverse;
-
- if (reverse) {
- mAnimator.reverse();
- } else {
- mAnimator.start();
- }
- }
-
- public void stopAnimation() {
- if (mAnimator != null) {
- mAnimator.cancel();
- mAnimator = null;
- }
-
- mReversing = false;
-
- setValue(0);
- }
-
- public boolean isStarted() {
- return mAnimator != null && mAnimator.isStarted();
- }
- }
-
- public void setPhotoFlipFraction(final float fraction) {
- mPhotoFlipAnimator.setValue(fraction);
- }
-
public String getAccount() {
return mAccount;
}
diff --git a/src/com/android/mail/browse/SwipeableConversationItemView.java b/src/com/android/mail/browse/SwipeableConversationItemView.java
index cd17c2f..919a5aa 100644
--- a/src/com/android/mail/browse/SwipeableConversationItemView.java
+++ b/src/com/android/mail/browse/SwipeableConversationItemView.java
@@ -28,7 +28,6 @@
import com.android.mail.providers.Conversation;
import com.android.mail.providers.Folder;
import com.android.mail.ui.AnimatedAdapter;
-import com.android.mail.ui.AnimatedAdapter.ConversationListListener;
import com.android.mail.ui.ControllableActivity;
import com.android.mail.ui.ConversationSelectionSet;
@@ -56,15 +55,14 @@
}
public void bind(final Conversation conversation, final ControllableActivity activity,
- final ConversationListListener conversationListListener,
final ConversationSelectionSet set, final Folder folder,
final int checkboxOrSenderImage, final boolean showAttachmentPreviews,
final boolean parallaxSpeedAlternative, final boolean parallaxDirectionAlternative,
final boolean swipeEnabled, final boolean priorityArrowsEnabled,
final AnimatedAdapter animatedAdapter) {
- mConversationItemView.bind(conversation, activity, conversationListListener, set, folder,
- checkboxOrSenderImage, showAttachmentPreviews, parallaxSpeedAlternative,
- parallaxDirectionAlternative, swipeEnabled, priorityArrowsEnabled, animatedAdapter);
+ mConversationItemView.bind(conversation, activity, set, folder, checkboxOrSenderImage,
+ showAttachmentPreviews, parallaxSpeedAlternative, parallaxDirectionAlternative,
+ swipeEnabled, priorityArrowsEnabled, animatedAdapter);
}
public void startUndoAnimation(AnimatorListener listener, boolean swipe) {
diff --git a/src/com/android/mail/photomanager/ContactPhotoManager.java b/src/com/android/mail/photomanager/ContactPhotoManager.java
deleted file mode 100644
index 06184b0..0000000
--- a/src/com/android/mail/photomanager/ContactPhotoManager.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.mail.photomanager;
-
-import android.content.ContentResolver;
-import android.content.Context;
-import android.text.TextUtils;
-import android.util.LruCache;
-
-import com.android.mail.ContactInfo;
-import com.android.mail.SenderInfoLoader;
-import com.android.mail.ui.ImageCanvas;
-import com.android.mail.utils.LogUtils;
-import com.google.common.base.Objects;
-import com.google.common.collect.ImmutableMap;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Asynchronously loads contact photos and maintains a cache of photos.
- */
-public class ContactPhotoManager extends PhotoManager {
- public static final String CONTACT_PHOTO_SERVICE = "contactPhotos";
-
- /**
- * An LRU cache for photo ids mapped to contact addresses.
- */
- private final LruCache<String, Long> mPhotoIdCache;
- private final LetterTileProvider mLetterTileProvider;
-
- /** Cache size for {@link #mPhotoIdCache}. Starting with 500 entries. */
- private static final int PHOTO_ID_CACHE_SIZE = 500;
-
- /**
- * Requests the singleton instance with data bound from the available authenticators. This
- * method can safely be called from the UI thread.
- */
- public static ContactPhotoManager getInstance(Context context) {
- Context applicationContext = context.getApplicationContext();
- ContactPhotoManager service =
- (ContactPhotoManager) applicationContext.getSystemService(CONTACT_PHOTO_SERVICE);
- if (service == null) {
- service = createContactPhotoManager(applicationContext);
- LogUtils.e(TAG, "No contact photo service in context: " + applicationContext);
- }
- return service;
- }
-
- public static synchronized ContactPhotoManager createContactPhotoManager(Context context) {
- return new ContactPhotoManager(context);
- }
-
- public static int generateHash(ImageCanvas view, int pos, Object key) {
- return Objects.hashCode(view, pos, key);
- }
-
- private ContactPhotoManager(Context context) {
- super(context);
- mPhotoIdCache = new LruCache<String, Long>(PHOTO_ID_CACHE_SIZE);
- mLetterTileProvider = new LetterTileProvider(context);
- }
-
- @Override
- protected DefaultImageProvider getDefaultImageProvider() {
- return mLetterTileProvider;
- }
-
- @Override
- protected int getHash(PhotoIdentifier id, ImageCanvas view) {
- final ContactIdentifier contactId = (ContactIdentifier) id;
- return generateHash(view, contactId.pos, contactId.getKey());
- }
-
- @Override
- protected PhotoLoaderThread getLoaderThread(ContentResolver contentResolver) {
- return new ContactPhotoLoaderThread(contentResolver);
- }
-
- @Override
- public void clear() {
- super.clear();
- mPhotoIdCache.evictAll();
- }
-
- public static class ContactIdentifier extends PhotoIdentifier {
- public final String name;
- public final String emailAddress;
- public final int pos;
-
- public ContactIdentifier(String name, String emailAddress, int pos) {
- this.name = name;
- this.emailAddress = emailAddress;
- this.pos = pos;
- }
-
- @Override
- public boolean isValid() {
- return !TextUtils.isEmpty(emailAddress);
- }
-
- @Override
- public Object getKey() {
- return emailAddress;
- }
-
- @Override
- public int hashCode() {
- int hash = 17;
- hash = 31 * hash + (emailAddress != null ? emailAddress.hashCode() : 0);
- hash = 31 * hash + (name != null ? name.hashCode() : 0);
- hash = 31 * hash + pos;
- return hash;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- ContactIdentifier other = (ContactIdentifier) obj;
- return Objects.equal(emailAddress, other.emailAddress)
- && Objects.equal(name, other.name) && Objects.equal(pos, other.pos);
- }
-
- @Override
- public String toString() {
- final StringBuilder sb = new StringBuilder("{");
- sb.append(super.toString());
- sb.append(" name=");
- sb.append(name);
- sb.append(" email=");
- sb.append(emailAddress);
- sb.append(" pos=");
- sb.append(pos);
- sb.append("}");
- return sb.toString();
- }
-
- @Override
- public int compareTo(PhotoIdentifier another) {
- return 0;
- }
- }
-
- public class ContactPhotoLoaderThread extends PhotoLoaderThread {
- public ContactPhotoLoaderThread(ContentResolver resolver) {
- super(resolver);
- }
-
- @Override
- protected Map<String, BitmapHolder> loadPhotos(Collection<Request> requests) {
- Map<String, BitmapHolder> photos = new HashMap<String, BitmapHolder>(requests.size());
-
- Set<String> addresses = new HashSet<String>();
- Set<Long> photoIds = new HashSet<Long>();
- HashMap<Long, String> photoIdMap = new HashMap<Long, String>();
-
- Long match;
- String emailAddress;
- for (Request request : requests) {
- emailAddress = (String) request.getKey();
- match = mPhotoIdCache.get(emailAddress);
- if (match != null) {
- photoIds.add(match);
- photoIdMap.put(match, emailAddress);
- } else {
- addresses.add(emailAddress);
- }
- }
-
- // get the Map of email addresses to ContactInfo
- ImmutableMap<String, ContactInfo> emailAddressToContactInfoMap =
- SenderInfoLoader.loadContactPhotos(
- getResolver(), addresses, false /* decodeBitmaps */);
-
- // Put all entries into photos map: a mapping of email addresses to photoBytes.
- // If there is no ContactInfo, it means we couldn't get a photo for this
- // address so just put null in for the bytes so that the crazy caching
- // works properly and we don't get an infinite loop of GC churn.
- if (emailAddressToContactInfoMap != null) {
- for (final String address : addresses) {
- final ContactInfo info = emailAddressToContactInfoMap.get(address);
- photos.put(address,
- new BitmapHolder(info != null ? info.photoBytes : null, -1, -1));
- }
- } else {
- // Still need to set a null result for all addresses, otherwise we end
- // up in the loop where photo manager attempts to load these again.
- for (final String address: addresses) {
- photos.put(address, new BitmapHolder(null, -1, -1));
- }
- }
-
- return photos;
- }
- }
-}
diff --git a/src/com/android/mail/photomanager/LetterTileProvider.java b/src/com/android/mail/photomanager/LetterTileProvider.java
index bc28223..0cb7505 100644
--- a/src/com/android/mail/photomanager/LetterTileProvider.java
+++ b/src/com/android/mail/photomanager/LetterTileProvider.java
@@ -29,12 +29,8 @@
import android.text.TextUtils;
import com.android.mail.R;
-import com.android.mail.photomanager.ContactPhotoManager.ContactIdentifier;
-import com.android.mail.photomanager.PhotoManager.DefaultImageProvider;
-import com.android.mail.photomanager.PhotoManager.PhotoIdentifier;
-import com.android.mail.ui.DividedImageCanvas;
-import com.android.mail.ui.ImageCanvas;
import com.android.mail.ui.ImageCanvas.Dimensions;
+import com.android.mail.utils.BitmapUtil;
import com.android.mail.utils.LogTag;
import com.android.mail.utils.LogUtils;
@@ -46,7 +42,8 @@
* tile. If there is no English alphabet character (or digit), it creates a
* bitmap with the default contact avatar.
*/
-public class LetterTileProvider implements DefaultImageProvider {
+@Deprecated
+public class LetterTileProvider {
private static final String TAG = LogTag.getLogTag();
private final Bitmap mDefaultBitmap;
private final Bitmap[] mBitmapBackgroundCache;
@@ -89,30 +86,6 @@
mDefaultColor = res.getColor(R.color.letter_tile_default_color);
}
- @Override
- public void applyDefaultImage(PhotoIdentifier id, ImageCanvas view, int extent) {
- ContactIdentifier contactIdentifier = (ContactIdentifier) id;
- DividedImageCanvas dividedImageView = (DividedImageCanvas) view;
-
- final String displayName = contactIdentifier.name;
- final String address = (String) contactIdentifier.getKey();
-
- // don't apply again if existing letter is there (and valid)
- if (dividedImageView.hasImageFor(address)) {
- return;
- }
-
- dividedImageView.getDesiredDimensions(address, mDims);
-
- final Bitmap bitmap = getLetterTile(mDims, displayName, address);
-
- if (bitmap == null) {
- return;
- }
-
- dividedImageView.addDivisionImage(bitmap, address);
- }
-
public Bitmap getLetterTile(final Dimensions dimensions, final String displayName,
final String address) {
final String display = !TextUtils.isEmpty(displayName) ? displayName : address;
diff --git a/src/com/android/mail/photomanager/MemInfoReader.java b/src/com/android/mail/photomanager/MemInfoReader.java
deleted file mode 100644
index f53c60c..0000000
--- a/src/com/android/mail/photomanager/MemInfoReader.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.mail.photomanager;
-
-import android.os.StrictMode;
-
-import java.io.FileInputStream;
-
-public class MemInfoReader {
- byte[] mBuffer = new byte[1024];
-
- private long mTotalSize;
- private long mFreeSize;
- private long mCachedSize;
-
- private static boolean matchText(byte[] buffer, int index, String text) {
- int N = text.length();
- if ((index + N) >= buffer.length) {
- return false;
- }
- for (int i = 0; i < N; i++) {
- if (buffer[index + i] != text.charAt(i)) {
- return false;
- }
- }
- return true;
- }
-
- private static long extractMemValue(byte[] buffer, int index) {
- while (index < buffer.length && buffer[index] != '\n') {
- if (buffer[index] >= '0' && buffer[index] <= '9') {
- int start = index;
- index++;
- while (index < buffer.length && buffer[index] >= '0' && buffer[index] <= '9') {
- index++;
- }
- String str = new String(buffer, 0, start, index - start);
- return ((long) Integer.parseInt(str)) * 1024;
- }
- index++;
- }
- return 0;
- }
-
- public void readMemInfo() {
- // Permit disk reads here, as /proc/meminfo isn't really "on
- // disk" and should be fast. TODO: make BlockGuard ignore
- // /proc/ and /sys/ files perhaps?
- StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskReads();
- try {
- mTotalSize = 0;
- mFreeSize = 0;
- mCachedSize = 0;
- FileInputStream is = new FileInputStream("/proc/meminfo");
- int len = is.read(mBuffer);
- is.close();
- final int BUFLEN = mBuffer.length;
- int count = 0;
- for (int i = 0; i < len && count < 3; i++) {
- if (matchText(mBuffer, i, "MemTotal")) {
- i += 8;
- mTotalSize = extractMemValue(mBuffer, i);
- count++;
- } else if (matchText(mBuffer, i, "MemFree")) {
- i += 7;
- mFreeSize = extractMemValue(mBuffer, i);
- count++;
- } else if (matchText(mBuffer, i, "Cached")) {
- i += 6;
- mCachedSize = extractMemValue(mBuffer, i);
- count++;
- }
- while (i < BUFLEN && mBuffer[i] != '\n') {
- i++;
- }
- }
- } catch (java.io.FileNotFoundException e) {
- } catch (java.io.IOException e) {
- } finally {
- StrictMode.setThreadPolicy(savedPolicy);
- }
- }
-
- public long getTotalSize() {
- return mTotalSize;
- }
-
- public long getFreeSize() {
- return mFreeSize;
- }
-
- public long getCachedSize() {
- return mCachedSize;
- }
-}
diff --git a/src/com/android/mail/photomanager/MemoryUtils.java b/src/com/android/mail/photomanager/MemoryUtils.java
deleted file mode 100644
index 4992026..0000000
--- a/src/com/android/mail/photomanager/MemoryUtils.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.mail.photomanager;
-
-public class MemoryUtils {
- private MemoryUtils() {
- }
-
- public static final int LARGE_RAM_THRESHOLD = 640 * 1024 * 1024;
- private static long sTotalMemorySize = -1;
-
- public static long getTotalMemorySize() {
- if (sTotalMemorySize < 0) {
- MemInfoReader reader = new MemInfoReader();
- reader.readMemInfo();
-
- // getTotalSize() returns the "MemTotal" value from /proc/meminfo.
- // Because the linux kernel doesn't see all the RAM on the system
- // (e.g. GPU takes some),
- // this is usually smaller than the actual RAM size.
- sTotalMemorySize = reader.getTotalSize();
- }
- return sTotalMemorySize;
- }
-}
diff --git a/src/com/android/mail/photomanager/PhotoManager.java b/src/com/android/mail/photomanager/PhotoManager.java
deleted file mode 100644
index 94f809d..0000000
--- a/src/com/android/mail/photomanager/PhotoManager.java
+++ /dev/null
@@ -1,993 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.mail.photomanager;
-
-import android.content.ComponentCallbacks2;
-import android.content.ContentResolver;
-import android.content.Context;
-import android.content.res.Configuration;
-import android.graphics.Bitmap;
-import android.os.Handler;
-import android.os.Handler.Callback;
-import android.os.HandlerThread;
-import android.os.Message;
-import android.os.Process;
-import android.util.LruCache;
-
-import com.android.mail.ui.ImageCanvas;
-import com.android.mail.utils.LogUtils;
-import com.android.mail.utils.Utils;
-import com.google.common.base.Objects;
-import com.google.common.collect.Lists;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.PriorityQueue;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Asynchronously loads photos and maintains a cache of photos
- */
-public abstract class PhotoManager implements ComponentCallbacks2, Callback {
- /**
- * Get the default image provider that draws while the photo is being
- * loaded.
- */
- protected abstract DefaultImageProvider getDefaultImageProvider();
-
- /**
- * Generate a hashcode unique to each request.
- */
- protected abstract int getHash(PhotoIdentifier id, ImageCanvas view);
-
- /**
- * Return a specific implementation of PhotoLoaderThread.
- */
- protected abstract PhotoLoaderThread getLoaderThread(ContentResolver contentResolver);
-
- /**
- * Subclasses can implement this method to alert callbacks that images finished loading.
- * @param request The original request made.
- * @param success True if we successfully loaded the image from cache. False if we fell back
- * to the default image.
- */
- protected void onImageDrawn(final Request request, final boolean success) {
- // Subclasses can choose to do something about this
- }
-
- /**
- * Subclasses can implement this method to alert callbacks that images started loading.
- * @param request The original request made.
- */
- protected void onImageLoadStarted(final Request request) {
- // Subclasses can choose to do something about this
- }
-
- /**
- * Subclasses can implement this method to determine whether a previously loaded bitmap can
- * be reused for a new canvas size.
- * @param prevWidth The width of the previously loaded bitmap.
- * @param prevHeight The height of the previously loaded bitmap.
- * @param newWidth The width of the canvas this request is drawing on.
- * @param newHeight The height of the canvas this request is drawing on.
- * @return
- */
- protected boolean isSizeCompatible(int prevWidth, int prevHeight, int newWidth, int newHeight) {
- return true;
- }
-
- protected final Context getContext() {
- return mContext;
- }
-
- static final String TAG = "PhotoManager";
- static final boolean DEBUG = false; // Don't submit with true
- static final boolean DEBUG_SIZES = false; // Don't submit with true
-
- private static final String LOADER_THREAD_NAME = "PhotoLoader";
-
- /**
- * Type of message sent by the UI thread to itself to indicate that some photos
- * need to be loaded.
- */
- private static final int MESSAGE_REQUEST_LOADING = 1;
-
- /**
- * Type of message sent by the loader thread to indicate that some photos have
- * been loaded.
- */
- private static final int MESSAGE_PHOTOS_LOADED = 2;
-
- /**
- * Type of message sent by the loader thread to indicate that
- */
- private static final int MESSAGE_PHOTO_LOADING = 3;
-
- public interface DefaultImageProvider {
- /**
- * Applies the default avatar to the DividedImageView. Extent is an
- * indicator for the size (width or height). If darkTheme is set, the
- * avatar is one that looks better on dark background
- * @param id
- */
- public void applyDefaultImage(PhotoIdentifier id, ImageCanvas view, int extent);
- }
-
- /**
- * Maintains the state of a particular photo.
- */
- protected static class BitmapHolder {
- byte[] bytes;
- int width;
- int height;
-
- volatile boolean fresh;
-
- public BitmapHolder(byte[] bytes, int width, int height) {
- this.bytes = bytes;
- this.width = width;
- this.height = height;
- this.fresh = true;
- }
-
- @Override
- public String toString() {
- final StringBuilder sb = new StringBuilder("{");
- sb.append(super.toString());
- sb.append(" bytes=");
- sb.append(bytes);
- sb.append(" size=");
- sb.append(bytes == null ? 0 : bytes.length);
- sb.append(" width=");
- sb.append(width);
- sb.append(" height=");
- sb.append(height);
- sb.append(" fresh=");
- sb.append(fresh);
- sb.append("}");
- return sb.toString();
- }
- }
-
- // todo:ath caches should be member vars
- /**
- * An LRU cache for bitmap holders. The cache contains bytes for photos just
- * as they come from the database. Each holder has a soft reference to the
- * actual bitmap. The keys are decided by the implementation.
- */
- private static final LruCache<Object, BitmapHolder> sBitmapHolderCache;
-
- /**
- * Level 2 LRU cache for bitmaps. This is a smaller cache that holds
- * the most recently used bitmaps to save time on decoding
- * them from bytes (the bytes are stored in {@link #sBitmapHolderCache}.
- * The keys are decided by the implementation.
- */
- private static final LruCache<BitmapIdentifier, Bitmap> sBitmapCache;
-
- /** Cache size for {@link #sBitmapHolderCache} for devices with "large" RAM. */
- private static final int HOLDER_CACHE_SIZE = 2000000;
-
- /** Cache size for {@link #sBitmapCache} for devices with "large" RAM. */
- private static final int BITMAP_CACHE_SIZE = 1024 * 1024 * 8; // 8MB
-
- /** For debug: How many times we had to reload cached photo for a stale entry */
- private static final AtomicInteger sStaleCacheOverwrite = new AtomicInteger();
-
- /** For debug: How many times we had to reload cached photo for a fresh entry. Should be 0. */
- private static final AtomicInteger sFreshCacheOverwrite = new AtomicInteger();
-
- static {
- final float cacheSizeAdjustment =
- (MemoryUtils.getTotalMemorySize() >= MemoryUtils.LARGE_RAM_THRESHOLD) ?
- 1.0f : 0.5f;
- final int holderCacheSize = (int) (cacheSizeAdjustment * HOLDER_CACHE_SIZE);
- sBitmapHolderCache = new LruCache<Object, BitmapHolder>(holderCacheSize) {
- @Override protected int sizeOf(Object key, BitmapHolder value) {
- return value.bytes != null ? value.bytes.length : 0;
- }
-
- @Override protected void entryRemoved(
- boolean evicted, Object key, BitmapHolder oldValue, BitmapHolder newValue) {
- if (DEBUG) dumpStats();
- }
- };
- final int bitmapCacheSize = (int) (cacheSizeAdjustment * BITMAP_CACHE_SIZE);
- sBitmapCache = new LruCache<BitmapIdentifier, Bitmap>(bitmapCacheSize) {
- @Override protected int sizeOf(BitmapIdentifier key, Bitmap value) {
- return value.getByteCount();
- }
-
- @Override protected void entryRemoved(
- boolean evicted, BitmapIdentifier key, Bitmap oldValue, Bitmap newValue) {
- if (DEBUG) dumpStats();
- }
- };
- LogUtils.i(TAG, "Cache adj: " + cacheSizeAdjustment);
- if (DEBUG) {
- LogUtils.d(TAG, "Cache size: " + btk(sBitmapHolderCache.maxSize())
- + " + " + btk(sBitmapCache.maxSize()));
- }
- }
-
- /**
- * A map from ImageCanvas hashcode to the corresponding photo ID or uri,
- * encapsulated in a request. The request may swapped out before the photo
- * loading request is started.
- */
- private final Map<Integer, Request> mPendingRequests = Collections.synchronizedMap(
- new HashMap<Integer, Request>());
-
- /**
- * Handler for messages sent to the UI thread.
- */
- private final Handler mMainThreadHandler = new Handler(this);
-
- /**
- * Thread responsible for loading photos from the database. Created upon
- * the first request.
- */
- private PhotoLoaderThread mLoaderThread;
-
- /**
- * A gate to make sure we only send one instance of MESSAGE_PHOTOS_NEEDED at a time.
- */
- private boolean mLoadingRequested;
-
- /**
- * Flag indicating if the image loading is paused.
- */
- private boolean mPaused;
-
- private final Context mContext;
-
- public PhotoManager(Context context) {
- mContext = context;
- }
-
- public void loadThumbnail(PhotoIdentifier id, ImageCanvas view) {
- loadThumbnail(id, view, null);
- }
-
- /**
- * Load an image
- *
- * @param dimensions Preferred dimensions
- */
- public void loadThumbnail(final PhotoIdentifier id, final ImageCanvas view,
- final ImageCanvas.Dimensions dimensions) {
- Utils.traceBeginSection("Load thumbnail");
- final DefaultImageProvider defaultProvider = getDefaultImageProvider();
- final Request request = new Request(id, defaultProvider, view, dimensions);
- final int hashCode = request.hashCode();
-
- if (!id.isValid()) {
- // No photo is needed
- request.applyDefaultImage();
- onImageDrawn(request, false);
- mPendingRequests.remove(hashCode);
- } else if (mPendingRequests.containsKey(hashCode)) {
- LogUtils.d(TAG, "load request dropped for %s", id);
- } else {
- if (DEBUG) LogUtils.v(TAG, "loadPhoto request: %s", id.getKey());
- loadPhoto(hashCode, request);
- }
- Utils.traceEndSection();
- }
-
- private void loadPhoto(int hashCode, Request request) {
- if (DEBUG) {
- LogUtils.v(TAG, "NEW IMAGE REQUEST key=%s r=%s thread=%s",
- request.getKey(),
- request,
- Thread.currentThread());
- }
-
- boolean loaded = loadCachedPhoto(request, false);
- if (loaded) {
- if (DEBUG) {
- LogUtils.v(TAG, "image request, cache hit. request queue size=%s",
- mPendingRequests.size());
- }
- } else {
- if (DEBUG) {
- LogUtils.d(TAG, "image request, cache miss: key=%s", request.getKey());
- }
- mPendingRequests.put(hashCode, request);
- if (!mPaused) {
- // Send a request to start loading photos
- requestLoading();
- }
- }
- }
-
- /**
- * Remove photo from the supplied image view. This also cancels current pending load request
- * inside this photo manager.
- */
- public void removePhoto(int hashcode) {
- Request r = mPendingRequests.remove(hashcode);
- if (r != null) {
- LogUtils.d(TAG, "removed request %s", r.getKey());
- }
- }
-
- private void ensureLoaderThread() {
- if (mLoaderThread == null) {
- mLoaderThread = getLoaderThread(mContext.getContentResolver());
- mLoaderThread.start();
- }
- }
-
- /**
- * Checks if the photo is present in cache. If so, sets the photo on the view.
- *
- * @param request Determines which image to load from cache.
- * @param afterLoaderThreadFinished Pass true if calling after the LoaderThread has run. Pass
- * false if the Loader Thread hasn't made any attempts to
- * load images yet.
- * @return false if the photo needs to be (re)loaded from the provider.
- */
- private boolean loadCachedPhoto(final Request request,
- final boolean afterLoaderThreadFinished) {
- Utils.traceBeginSection("Load cached photo");
- final Bitmap cached = getCachedPhoto(request.bitmapKey);
- if (cached != null) {
- if (DEBUG) {
- LogUtils.v(TAG, "%s, key=%s decodedSize=%s thread=%s",
- afterLoaderThreadFinished ? "DECODED IMG READ"
- : "DECODED IMG CACHE HIT",
- request.getKey(),
- cached.getByteCount(),
- Thread.currentThread());
- }
- if (request.getView().getGeneration() == request.viewGeneration) {
- request.getView().drawImage(cached, request.getKey());
- onImageDrawn(request, true);
- }
- Utils.traceEndSection();
- return true;
- }
-
- // We couldn't load the requested image, so try to load a replacement.
- // This removes the flicker from SIMPLE to BEST transition.
- final Object replacementKey = request.getPhotoIdentifier().getKeyToShowInsteadOfDefault();
- if (replacementKey != null) {
- final BitmapIdentifier replacementBitmapKey = new BitmapIdentifier(replacementKey,
- request.bitmapKey.w, request.bitmapKey.h);
- final Bitmap cachedReplacement = getCachedPhoto(replacementBitmapKey);
- if (cachedReplacement != null) {
- if (DEBUG) {
- LogUtils.v(TAG, "%s, key=%s decodedSize=%s thread=%s",
- afterLoaderThreadFinished ? "DECODED IMG READ"
- : "DECODED IMG CACHE HIT",
- replacementKey,
- cachedReplacement.getByteCount(),
- Thread.currentThread());
- }
- if (request.getView().getGeneration() == request.viewGeneration) {
- request.getView().drawImage(cachedReplacement, request.getKey());
- onImageDrawn(request, true);
- }
- Utils.traceEndSection();
- return false;
- }
- }
-
- // We couldn't load any image, so draw a default image
- request.applyDefaultImage();
-
- final BitmapHolder holder = sBitmapHolderCache.get(request.getKey());
- // Check if we loaded null bytes, which means we meant to not draw anything.
- if (holder != null && holder.bytes == null) {
- onImageDrawn(request, holder.fresh);
- Utils.traceEndSection();
- return holder.fresh;
- }
- Utils.traceEndSection();
- return false;
- }
-
- /**
- * Takes care of retrieving the Bitmap from both the decoded and holder caches.
- */
- private static Bitmap getCachedPhoto(BitmapIdentifier bitmapKey) {
- Utils.traceBeginSection("Get cached photo");
- final Bitmap cached = sBitmapCache.get(bitmapKey);
- Utils.traceEndSection();
- return cached;
- }
-
- /**
- * Temporarily stops loading photos from the database.
- */
- public void pause() {
- LogUtils.d(TAG, "%s paused.", getClass().getName());
- mPaused = true;
- }
-
- /**
- * Resumes loading photos from the database.
- */
- public void resume() {
- LogUtils.d(TAG, "%s resumed.", getClass().getName());
- mPaused = false;
- if (DEBUG) dumpStats();
- if (!mPendingRequests.isEmpty()) {
- requestLoading();
- }
- }
-
- /**
- * Sends a message to this thread itself to start loading images. If the current
- * view contains multiple image views, all of those image views will get a chance
- * to request their respective photos before any of those requests are executed.
- * This allows us to load images in bulk.
- */
- private void requestLoading() {
- if (!mLoadingRequested) {
- mLoadingRequested = true;
- mMainThreadHandler.sendEmptyMessage(MESSAGE_REQUEST_LOADING);
- }
- }
-
- /**
- * Processes requests on the main thread.
- */
- @Override
- public boolean handleMessage(final Message msg) {
- switch (msg.what) {
- case MESSAGE_REQUEST_LOADING: {
- mLoadingRequested = false;
- if (!mPaused) {
- ensureLoaderThread();
- mLoaderThread.requestLoading();
- }
- return true;
- }
-
- case MESSAGE_PHOTOS_LOADED: {
- processLoadedImages();
- if (DEBUG) dumpStats();
- return true;
- }
-
- case MESSAGE_PHOTO_LOADING: {
- final int hashcode = msg.arg1;
- final Request request = mPendingRequests.get(hashcode);
- onImageLoadStarted(request);
- return true;
- }
- }
- return false;
- }
-
- /**
- * Goes over pending loading requests and displays loaded photos. If some of the
- * photos still haven't been loaded, sends another request for image loading.
- */
- private void processLoadedImages() {
- Utils.traceBeginSection("process loaded images");
- final List<Integer> toRemove = Lists.newArrayList();
- for (final Integer hash : mPendingRequests.keySet()) {
- final Request request = mPendingRequests.get(hash);
- final boolean loaded = loadCachedPhoto(request, true);
- // Request can go through multiple attempts if the LoaderThread fails to load any
- // images for it, or if the images it loads are evicted from the cache before we
- // could access them in the main thread.
- if (loaded || request.attempts > 2) {
- toRemove.add(hash);
- }
- }
- for (final Integer key : toRemove) {
- mPendingRequests.remove(key);
- }
-
- if (!mPaused && !mPendingRequests.isEmpty()) {
- LogUtils.d(TAG, "Finished loading batch. %d still have to be loaded.",
- mPendingRequests.size());
- requestLoading();
- }
- Utils.traceEndSection();
- }
-
- /**
- * Stores the supplied bitmap in cache.
- */
- private static void cacheBitmapHolder(final String cacheKey, final BitmapHolder holder) {
- if (DEBUG) {
- BitmapHolder prev = sBitmapHolderCache.get(cacheKey);
- if (prev != null && prev.bytes != null) {
- LogUtils.d(TAG, "Overwriting cache: key=" + cacheKey
- + (prev.fresh ? " FRESH" : " stale"));
- if (prev.fresh) {
- sFreshCacheOverwrite.incrementAndGet();
- } else {
- sStaleCacheOverwrite.incrementAndGet();
- }
- }
- LogUtils.d(TAG, "Caching data: key=" + cacheKey + ", "
- + (holder.bytes == null ? "<null>" : btk(holder.bytes.length)));
- }
-
- sBitmapHolderCache.put(cacheKey, holder);
- }
-
- protected static void cacheBitmap(final BitmapIdentifier bitmapKey, final Bitmap bitmap) {
- sBitmapCache.put(bitmapKey, bitmap);
- }
-
- // ComponentCallbacks2
- @Override
- public void onConfigurationChanged(Configuration newConfig) {
- }
-
- // ComponentCallbacks2
- @Override
- public void onLowMemory() {
- }
-
- // ComponentCallbacks2
- @Override
- public void onTrimMemory(int level) {
- if (DEBUG) LogUtils.d(TAG, "onTrimMemory: " + level);
- if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
- // Clear the caches. Note all pending requests will be removed too.
- clear();
- }
- }
-
- public void clear() {
- if (DEBUG) LogUtils.d(TAG, "clear");
- mPendingRequests.clear();
- sBitmapHolderCache.evictAll();
- sBitmapCache.evictAll();
- }
-
- /**
- * Dump cache stats on logcat.
- */
- private static void dumpStats() {
- if (!DEBUG) {
- return;
- }
- int numHolders = 0;
- int rawBytes = 0;
- int bitmapBytes = 0;
- int numBitmaps = 0;
- for (BitmapHolder h : sBitmapHolderCache.snapshot().values()) {
- numHolders++;
- if (h.bytes != null) {
- rawBytes += h.bytes.length;
- numBitmaps++;
- }
- }
- LogUtils.d(TAG,
- "L1: " + btk(rawBytes) + " + " + btk(bitmapBytes) + " = "
- + btk(rawBytes + bitmapBytes) + ", " + numHolders + " holders, "
- + numBitmaps + " bitmaps, avg: " + btk(safeDiv(rawBytes, numBitmaps)));
- LogUtils.d(TAG, "L1 Stats: %s, overwrite: fresh=%s stale=%s", sBitmapHolderCache,
- sFreshCacheOverwrite.get(), sStaleCacheOverwrite.get());
-
- numBitmaps = 0;
- bitmapBytes = 0;
- for (Bitmap b : sBitmapCache.snapshot().values()) {
- numBitmaps++;
- bitmapBytes += b.getByteCount();
- }
- LogUtils.d(TAG, "L2: " + btk(bitmapBytes) + ", " + numBitmaps + " bitmaps" + ", avg: "
- + btk(safeDiv(bitmapBytes, numBitmaps)));
- // We don't get from L2 cache, so L2 stats is meaningless.
- }
-
- /** Converts bytes to K bytes, rounding up. Used only for debug log. */
- private static String btk(int bytes) {
- return ((bytes + 1023) / 1024) + "K";
- }
-
- private static final int safeDiv(int dividend, int divisor) {
- return (divisor == 0) ? 0 : (dividend / divisor);
- }
-
- public static abstract class PhotoIdentifier implements Comparable<PhotoIdentifier> {
- /**
- * If this returns false, the PhotoManager will not attempt to load the
- * bitmap. Instead, the default image provider will be used.
- */
- public abstract boolean isValid();
-
- /**
- * Identifies this request.
- */
- public abstract Object getKey();
-
- /**
- * Replacement key to try to load from cache instead of drawing the default image. This
- * is useful when we've already loaded a SIMPLE rendition, and are now loading the BEST
- * rendition. We want the BEST image to appear seamlessly on top of the existing SIMPLE
- * image.
- */
- public Object getKeyToShowInsteadOfDefault() {
- return null;
- }
- }
-
- /**
- * The thread that performs loading of photos from the database.
- */
- protected abstract class PhotoLoaderThread extends HandlerThread implements Callback {
-
- /**
- * Return photos mapped from {@link Request#getKey()} to the photo for
- * that request.
- */
- protected abstract Map<String, BitmapHolder> loadPhotos(Collection<Request> requests);
-
- private static final int MESSAGE_LOAD_PHOTOS = 0;
-
- private final ContentResolver mResolver;
-
- private Handler mLoaderThreadHandler;
-
- public PhotoLoaderThread(ContentResolver resolver) {
- super(LOADER_THREAD_NAME, Process.THREAD_PRIORITY_BACKGROUND);
- mResolver = resolver;
- }
-
- protected ContentResolver getResolver() {
- return mResolver;
- }
-
- public void ensureHandler() {
- if (mLoaderThreadHandler == null) {
- mLoaderThreadHandler = new Handler(getLooper(), this);
- }
- }
-
- /**
- * Sends a message to this thread to load requested photos. Cancels a preloading
- * request, if any: we don't want preloading to impede loading of the photos
- * we need to display now.
- */
- public void requestLoading() {
- ensureHandler();
- mLoaderThreadHandler.sendEmptyMessage(MESSAGE_LOAD_PHOTOS);
- }
-
- /**
- * Receives the above message, loads photos and then sends a message
- * to the main thread to process them.
- */
- @Override
- public boolean handleMessage(Message msg) {
- switch (msg.what) {
- case MESSAGE_LOAD_PHOTOS:
- loadPhotosInBackground();
- break;
- }
- return true;
- }
-
- /**
- * Subclasses may specify the maximum number of requests to be given at a time to
- * #loadPhotos(). For batch count N, the UI will be updated with up to N images at a time.
- *
- * @return A positive integer if you would like to limit the number of
- * items in a single batch.
- */
- protected int getMaxBatchCount() {
- return -1;
- }
-
- private void loadPhotosInBackground() {
- Utils.traceBeginSection("pre processing");
- final Collection<Request> loadRequests = new HashSet<PhotoManager.Request>();
- final Collection<Request> decodeRequests = new HashSet<PhotoManager.Request>();
- final PriorityQueue<Request> requests;
- synchronized (mPendingRequests) {
- requests = new PriorityQueue<Request>(mPendingRequests.values());
- }
-
- int batchCount = 0;
- int maxBatchCount = getMaxBatchCount();
- while (!requests.isEmpty()) {
- Request request = requests.poll();
- final BitmapHolder holder = sBitmapHolderCache
- .get(request.getKey());
- if (holder == null || holder.bytes == null || !holder.fresh || !isSizeCompatible(
- holder.width, holder.height, request.bitmapKey.w, request.bitmapKey.h)) {
- loadRequests.add(request);
- decodeRequests.add(request);
- batchCount++;
-
- final Message msg = Message.obtain();
- msg.what = MESSAGE_PHOTO_LOADING;
- msg.arg1 = request.hashCode();
- mMainThreadHandler.sendMessage(msg);
- } else {
- // Even if the image load is already done, this particular decode configuration
- // may not yet have run. Be sure to add it to the queue.
- if (sBitmapCache.get(request.bitmapKey) == null) {
- decodeRequests.add(request);
- }
- }
- request.attempts++;
- if (maxBatchCount > 0 && batchCount >= maxBatchCount) {
- break;
- }
- }
- Utils.traceEndSection();
-
- Utils.traceBeginSection("load photos");
- // Ask subclass to do the actual loading
- final Map<String, BitmapHolder> photosMap = loadPhotos(loadRequests);
- Utils.traceEndSection();
-
- if (DEBUG) {
- LogUtils.d(TAG,
- "worker thread completed read request batch. inputN=%s outputN=%s",
- loadRequests.size(),
- photosMap.size());
- }
- Utils.traceBeginSection("post processing");
- for (String cacheKey : photosMap.keySet()) {
- if (DEBUG) {
- LogUtils.d(TAG,
- "worker thread completed read request key=%s byteCount=%s thread=%s",
- cacheKey,
- photosMap.get(cacheKey) == null ? 0
- : photosMap.get(cacheKey).bytes.length,
- Thread.currentThread());
- }
- cacheBitmapHolder(cacheKey, photosMap.get(cacheKey));
- }
-
- for (Request r : decodeRequests) {
- if (sBitmapCache.get(r.bitmapKey) != null) {
- continue;
- }
-
- final Object cacheKey = r.getKey();
- final BitmapHolder holder = sBitmapHolderCache.get(cacheKey);
- if (holder == null || holder.bytes == null || !holder.fresh || !isSizeCompatible(
- holder.width, holder.height, r.bitmapKey.w, r.bitmapKey.h)) {
- continue;
- }
-
- final int w = r.bitmapKey.w;
- final int h = r.bitmapKey.h;
- final byte[] src = holder.bytes;
-
- if (w == 0 || h == 0) {
- LogUtils.e(TAG, new Error(), "bad dimensions for request=%s w/h=%s/%s",
- r, w, h);
- }
-
- final Bitmap decoded = BitmapUtil.decodeByteArrayWithCenterCrop(src, w, h);
- if (DEBUG) {
- LogUtils.i(TAG,
- "worker thread completed decode bmpKey=%s decoded=%s holder=%s",
- r.bitmapKey, decoded, holder);
- }
-
- if (decoded != null) {
- cacheBitmap(r.bitmapKey, decoded);
- }
- }
- Utils.traceEndSection();
-
- mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
- }
-
- protected String createInQuery(String value, int itemCount) {
- // Build first query
- StringBuilder query = new StringBuilder().append(value + " IN (");
- appendQuestionMarks(query, itemCount);
- query.append(')');
- return query.toString();
- }
-
- protected void appendQuestionMarks(StringBuilder query, int itemCount) {
- boolean first = true;
- for (int i = 0; i < itemCount; i++) {
- if (first) {
- first = false;
- } else {
- query.append(',');
- }
- query.append('?');
- }
- }
- }
-
- /**
- * An object to uniquely identify a combination of (Request + decoded size). Multiple requests
- * may require the same src image, but want to decode it into different sizes.
- */
- public static final class BitmapIdentifier {
- public final Object key;
- public final int w;
- public final int h;
-
- // OK to be static as long as all Requests are created on the same
- // thread
- private static final ImageCanvas.Dimensions sWorkDims = new ImageCanvas.Dimensions();
-
- public static BitmapIdentifier getBitmapKey(PhotoIdentifier id, ImageCanvas view,
- ImageCanvas.Dimensions dimensions) {
- final int width;
- final int height;
- if (dimensions != null) {
- width = dimensions.width;
- height = dimensions.height;
- } else {
- view.getDesiredDimensions(id.getKey(), sWorkDims);
- width = sWorkDims.width;
- height = sWorkDims.height;
- }
- return new BitmapIdentifier(id.getKey(), width, height);
- }
-
- public BitmapIdentifier(Object key, int w, int h) {
- this.key = key;
- this.w = w;
- this.h = h;
- }
-
- @Override
- public int hashCode() {
- int hash = 19;
- hash = 31 * hash + key.hashCode();
- hash = 31 * hash + w;
- hash = 31 * hash + h;
- return hash;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (obj == null || obj.getClass() != getClass()) {
- return false;
- } else if (obj == this) {
- return true;
- }
- final BitmapIdentifier o = (BitmapIdentifier) obj;
- return Objects.equal(key, o.key) && w == o.w && h == o.h;
- }
-
- @Override
- public String toString() {
- final StringBuilder sb = new StringBuilder("{");
- sb.append(super.toString());
- sb.append(" key=");
- sb.append(key);
- sb.append(" w=");
- sb.append(w);
- sb.append(" h=");
- sb.append(h);
- sb.append("}");
- return sb.toString();
- }
- }
-
- /**
- * A holder for a contact photo request.
- */
- public final class Request implements Comparable<Request> {
- private final int mRequestedExtent;
- private final DefaultImageProvider mDefaultProvider;
- private final PhotoIdentifier mPhotoIdentifier;
- private final ImageCanvas mView;
- public final BitmapIdentifier bitmapKey;
- public final int viewGeneration;
- public int attempts;
-
- private Request(final PhotoIdentifier photoIdentifier,
- final DefaultImageProvider defaultProvider, final ImageCanvas view,
- final ImageCanvas.Dimensions dimensions) {
- mPhotoIdentifier = photoIdentifier;
- mRequestedExtent = -1;
- mDefaultProvider = defaultProvider;
- mView = view;
- viewGeneration = view.getGeneration();
-
- bitmapKey = BitmapIdentifier.getBitmapKey(photoIdentifier, mView, dimensions);
- }
-
- public ImageCanvas getView() {
- return mView;
- }
-
- public PhotoIdentifier getPhotoIdentifier() {
- return mPhotoIdentifier;
- }
-
- /**
- * @see PhotoIdentifier#getKey()
- */
- public Object getKey() {
- return mPhotoIdentifier.getKey();
- }
-
- @Override
- public int hashCode() {
- return getHash(mPhotoIdentifier, mView);
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) return true;
- if (obj == null) return false;
- if (getClass() != obj.getClass()) return false;
- final Request that = (Request) obj;
- if (mRequestedExtent != that.mRequestedExtent) return false;
- if (!Objects.equal(mPhotoIdentifier, that.mPhotoIdentifier)) return false;
- if (!Objects.equal(mView, that.mView)) return false;
- // Don't compare equality of mDarkTheme because it is only used in the default contact
- // photo case. When the contact does have a photo, the contact photo is the same
- // regardless of mDarkTheme, so we shouldn't need to put the photo request on the queue
- // twice.
- return true;
- }
-
- @Override
- public String toString() {
- final StringBuilder sb = new StringBuilder("{");
- sb.append(super.toString());
- sb.append(" key=");
- sb.append(getKey());
- sb.append(" id=");
- sb.append(mPhotoIdentifier);
- sb.append(" mView=");
- sb.append(mView);
- sb.append(" mExtent=");
- sb.append(mRequestedExtent);
- sb.append(" bitmapKey=");
- sb.append(bitmapKey);
- sb.append(" viewGeneration=");
- sb.append(viewGeneration);
- sb.append("}");
- return sb.toString();
- }
-
- public void applyDefaultImage() {
- if (mView.getGeneration() != viewGeneration) {
- // This can legitimately happen when an ImageCanvas is reused and re-purposed to
- // house a new set of images (e.g. by ListView recycling).
- // Ignore this now-stale request.
- if (DEBUG) {
- LogUtils.d(TAG,
- "ImageCanvas skipping applyDefaultImage; no longer contains" +
- " item=%s canvas=%s", getKey(), mView);
- }
- }
- mDefaultProvider.applyDefaultImage(mPhotoIdentifier, mView, mRequestedExtent);
- }
-
- @Override
- public int compareTo(Request another) {
- // Hold off on loading Requests which have failed before so it don't hold up others
- if (attempts - another.attempts != 0) {
- return attempts - another.attempts;
- }
- return mPhotoIdentifier.compareTo(another.mPhotoIdentifier);
- }
- }
-}
diff --git a/src/com/android/mail/ui/AnimatedAdapter.java b/src/com/android/mail/ui/AnimatedAdapter.java
index fad7b3a..d47ea9c 100644
--- a/src/com/android/mail/ui/AnimatedAdapter.java
+++ b/src/com/android/mail/ui/AnimatedAdapter.java
@@ -40,6 +40,7 @@
import com.android.bitmap.DecodeAggregator;
import com.android.mail.R;
import com.android.mail.analytics.Analytics;
+import com.android.mail.bitmap.ContactResolver;
import com.android.mail.browse.ConversationCursor;
import com.android.mail.browse.ConversationItemView;
import com.android.mail.browse.ConversationItemViewCoordinates.CoordinatesCache;
@@ -93,17 +94,6 @@
private final Handler mHandler;
protected long mLastLeaveBehind = -1;
- private final BitmapCache mBitmapCache;
- private final DecodeAggregator mDecodeAggregator;
-
- public interface ConversationListListener {
- /**
- * @return <code>true</code> if the list is just exiting selection mode (so animations may
- * be required), <code>false</code> otherwise
- */
- boolean isExitingSelectionMode();
- }
-
private final AnimatorListener mAnimatorListener = new AnimatorListenerAdapter() {
@Override
@@ -184,7 +174,6 @@
/** True if priority inbox markers are enabled, false otherwise. */
private boolean mPriorityMarkersEnabled;
private final ControllableActivity mActivity;
- private final ConversationListListener mConversationListListener;
private final AccountObserver mAccountListener = new AccountObserver() {
@Override
public void onChanged(Account newAccount) {
@@ -250,31 +239,43 @@
private static final String LOG_TAG = LogTag.getLogTag();
private static final int INCREASE_WAIT_COUNT = 2;
- private static final int BITMAP_CACHE_TARGET_SIZE_BYTES = 0; // TODO: enable cache
+ private final BitmapCache mAttachmentPreviewsCache;
+ private final DecodeAggregator mAttachmentPreviewsDecodeAggregator;
+ private final BitmapCache mSendersImagesCache;
+ private final ContactResolver mContactResolver;
+
+ private static final int ATTACHMENT_PREVIEWS_CACHE_TARGET_SIZE_BYTES = 0; // TODO: enable cache
+ /** 339KB cache fits 10 bitmaps at 33856 bytes each. */
+ private static final int SENDERS_IMAGES_CACHE_TARGET_SIZE_BYTES = 1024 * 339;
/**
* This is the fractional portion of the total cache size above that's dedicated to non-pooled
* bitmaps. (This is basically the portion of cache dedicated to GIFs.)
*/
- private static final float BITMAP_CACHE_NON_POOLED_FRACTION = 0.1f;
+ private static final float ATTACHMENT_PREVIEWS_CACHE_NON_POOLED_FRACTION = 0.1f;
+ private static final float SENDERS_IMAGES_PREVIEWS_CACHE_NON_POOLED_FRACTION = 0f;
+ /** Each string has upper estimate of 50 bytes, so this cache would be 5KB. */
+ private static final int SENDERS_IMAGES_PREVIEWS_CACHE_NULL_CAPACITY = 100;
public AnimatedAdapter(Context context, ConversationCursor cursor,
ConversationSelectionSet batch, ControllableActivity activity,
- final ConversationListListener conversationListListener, SwipeableListView listView,
- final List<ConversationSpecialItemView> specialViews,
+ SwipeableListView listView, final List<ConversationSpecialItemView> specialViews,
final ObjectCursor<Folder> childFolders) {
super(context, -1, cursor, UIProvider.CONVERSATION_PROJECTION, null, 0);
mContext = context;
mBatchConversations = batch;
setAccount(mAccountListener.initialize(activity.getAccountController()));
mActivity = activity;
- mConversationListListener = conversationListListener;
mShowFooter = false;
mListView = listView;
mFolderViews = getNestedFolders(childFolders);
- mBitmapCache = new AltBitmapCache(BITMAP_CACHE_TARGET_SIZE_BYTES,
- BITMAP_CACHE_NON_POOLED_FRACTION);
- mDecodeAggregator = new DecodeAggregator();
+ mAttachmentPreviewsCache = new AltBitmapCache(ATTACHMENT_PREVIEWS_CACHE_TARGET_SIZE_BYTES,
+ ATTACHMENT_PREVIEWS_CACHE_NON_POOLED_FRACTION, 0);
+ mAttachmentPreviewsDecodeAggregator = new DecodeAggregator();
+ mSendersImagesCache = new AltBitmapCache(SENDERS_IMAGES_CACHE_TARGET_SIZE_BYTES,
+ SENDERS_IMAGES_PREVIEWS_CACHE_NON_POOLED_FRACTION,
+ SENDERS_IMAGES_PREVIEWS_CACHE_NULL_CAPACITY);
+ mContactResolver = new ContactResolver(mContext.getContentResolver(), mSendersImagesCache);
mHandler = new Handler();
if (sDismissAllShortDelay == -1) {
@@ -415,10 +416,10 @@
if (view == null) {
view = new SwipeableConversationItemView(context, mAccount.name);
}
- view.bind(conv, mActivity, mConversationListListener, mBatchConversations, mFolder,
- getCheckboxSetting(), getAttachmentPreviewsSetting(),
- getParallaxSpeedAlternativeSetting(), getParallaxDirectionAlternativeSetting(),
- mSwipeEnabled, mPriorityMarkersEnabled, this);
+ view.bind(conv, mActivity, mBatchConversations, mFolder, getCheckboxSetting(),
+ getAttachmentPreviewsSetting(), getParallaxSpeedAlternativeSetting(),
+ getParallaxDirectionAlternativeSetting(), mSwipeEnabled, mPriorityMarkersEnabled,
+ this);
return view;
}
@@ -803,10 +804,10 @@
SwipeableConversationItemView view = (SwipeableConversationItemView) super.getView(
position, null, parent);
view.reset();
- view.bind(conversation, mActivity, mConversationListListener, mBatchConversations, mFolder,
- getCheckboxSetting(), getAttachmentPreviewsSetting(),
- getParallaxSpeedAlternativeSetting(), getParallaxDirectionAlternativeSetting(),
- mSwipeEnabled, mPriorityMarkersEnabled, this);
+ view.bind(conversation, mActivity, mBatchConversations, mFolder, getCheckboxSetting(),
+ getAttachmentPreviewsSetting(), getParallaxSpeedAlternativeSetting(),
+ getParallaxDirectionAlternativeSetting(), mSwipeEnabled, mPriorityMarkersEnabled,
+ this);
mAnimatingViews.put(conversation.id, view);
return view;
}
@@ -1117,12 +1118,20 @@
return oldCursor;
}
- public BitmapCache getBitmapCache() {
- return mBitmapCache;
+ public BitmapCache getAttachmentPreviewsCache() {
+ return mAttachmentPreviewsCache;
}
- public DecodeAggregator getDecodeAggregator() {
- return mDecodeAggregator;
+ public DecodeAggregator getAttachmentPreviewsDecodeAggregator() {
+ return mAttachmentPreviewsDecodeAggregator;
+ }
+
+ public BitmapCache getSendersImagesCache() {
+ return mSendersImagesCache;
+ }
+
+ public ContactResolver getContactResolver() {
+ return mContactResolver;
}
/**
@@ -1178,7 +1187,7 @@
public void onScrollStateChanged(final int scrollState) {
final boolean scrolling = scrollState != OnScrollListener.SCROLL_STATE_IDLE;
- mBitmapCache.setBlocking(scrolling);
+ mAttachmentPreviewsCache.setBlocking(scrolling);
}
public int getViewMode() {
diff --git a/src/com/android/mail/ui/ConversationListFragment.java b/src/com/android/mail/ui/ConversationListFragment.java
index 32b8b3d..20a7c9f 100644
--- a/src/com/android/mail/ui/ConversationListFragment.java
+++ b/src/com/android/mail/ui/ConversationListFragment.java
@@ -60,7 +60,6 @@
import com.android.mail.providers.UIProvider.FolderCapabilities;
import com.android.mail.providers.UIProvider.FolderType;
import com.android.mail.providers.UIProvider.Swipe;
-import com.android.mail.ui.AnimatedAdapter.ConversationListListener;
import com.android.mail.ui.SwipeableListView.ListItemSwipedListener;
import com.android.mail.ui.SwipeableListView.ListItemsRemovedListener;
import com.android.mail.ui.ViewMode.ModeChangeListener;
@@ -358,8 +357,7 @@
}
mListAdapter = new AnimatedAdapter(mActivity.getApplicationContext(), conversationCursor,
- mActivity.getSelectedSet(), mActivity, mConversationListListener, mListView,
- specialItemViews, null);
+ mActivity.getSelectedSet(), mActivity, mListView, specialItemViews, null);
mListAdapter.addFooter(mFooterView);
mListView.setAdapter(mListAdapter);
mSelectedSet = mActivity.getSelectedSet();
@@ -743,15 +741,6 @@
mCallbacks.onConversationSelected(conv, false /* inLoaderCallbacks */);
}
- private final ConversationListListener mConversationListListener =
- new ConversationListListener() {
- @Override
- public boolean isExitingSelectionMode() {
- return System.currentTimeMillis() <
- (mSelectionModeExitedTimestamp + sSelectionModeAnimationDuration);
- }
- };
-
/**
* Sets the selected conversation to the position given here.
* @param cursorPosition The position of the conversation in the cursor (as opposed to
diff --git a/src/com/android/mail/ui/SwipeableListView.java b/src/com/android/mail/ui/SwipeableListView.java
index 627a375..2c0ca14 100644
--- a/src/com/android/mail/ui/SwipeableListView.java
+++ b/src/com/android/mail/ui/SwipeableListView.java
@@ -419,7 +419,6 @@
if (adapter != null) {
adapter.onScrollStateChanged(scrollState);
}
- ConversationItemView.setScrollStateChanged(scrollState);
}
}
diff --git a/src/com/android/mail/photomanager/BitmapUtil.java b/src/com/android/mail/utils/BitmapUtil.java
similarity index 93%
rename from src/com/android/mail/photomanager/BitmapUtil.java
rename to src/com/android/mail/utils/BitmapUtil.java
index 9c2ab2b..6f61f56 100644
--- a/src/com/android/mail/photomanager/BitmapUtil.java
+++ b/src/com/android/mail/utils/BitmapUtil.java
@@ -14,18 +14,17 @@
* limitations under the License.
*/
-package com.android.mail.photomanager;
+package com.android.mail.utils;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
-import com.android.mail.utils.LogUtils;
-
/**
* Provides static functions to decode bitmaps at the optimal size
*/
public class BitmapUtil {
+ private static final String TAG = LogTag.getLogTag();
private static final boolean DEBUG = false;
private BitmapUtil() {
@@ -53,7 +52,7 @@
opts.inJustDecodeBounds = false;
return BitmapFactory.decodeByteArray(src, 0, src.length, opts);
} catch (Throwable t) {
- LogUtils.w(PhotoManager.TAG, t, "unable to decode image");
+ LogUtils.w(TAG, t, "BitmapUtils unable to decode image");
return null;
}
}
@@ -73,7 +72,7 @@
return centerCrop(decoded, w, h);
} catch (Throwable t) {
- LogUtils.w(PhotoManager.TAG, t, "unable to crop image");
+ LogUtils.w(TAG, t, "BitmapUtils unable to crop image");
return null;
}
}
@@ -161,13 +160,13 @@
final Bitmap cropped = Bitmap.createBitmap(src, srcX, srcY, srcCroppedW, srcCroppedH, m,
true /* filter */);
- if (DEBUG) LogUtils.i(PhotoManager.TAG,
- "IN centerCrop, srcW/H=%s/%s desiredW/H=%s/%s srcX/Y=%s/%s" +
+ if (DEBUG) LogUtils.i(TAG,
+ "BitmapUtils IN centerCrop, srcW/H=%s/%s desiredW/H=%s/%s srcX/Y=%s/%s" +
" innerW/H=%s/%s scale=%s resultW/H=%s/%s",
srcWidth, srcHeight, w, h, srcX, srcY, srcCroppedW, srcCroppedH, scale,
cropped.getWidth(), cropped.getHeight());
if (DEBUG && (w != cropped.getWidth() || h != cropped.getHeight())) {
- LogUtils.e(PhotoManager.TAG, new Error(), "last center crop violated assumptions.");
+ LogUtils.e(TAG, new Error(), "BitmapUtils last center crop violated assumptions.");
}
return cropped;
