Update Dialer source to latest internal Google revision.

Previously, Android's Dialer app was developed in an internal Google
source control system and only exported to public during AOSP drops.

The Dialer team is now switching to a public development model similar
to the telephony team.

This CL represents all internal Google changes that were committed to
Dialer between the public O release and today's tip of tree on internal
master. This CL squashes those changes into a single commit.
In subsequent changes, changes will be exported on a per-commit basis.

Test: make, flash install, run
Merged-In: I45270eaa8ce732d71a1bd84b08c7fa0e99af3160
Change-Id: I529aaeb88535b9533c0ae4ef4e6c1222d4e0f1c8
PiperOrigin-RevId: 167068436

1 files changed, 1266 insertions, 0 deletions

diff --git a/java/com/android/dialer/contactphoto/ContactPhotoManagerImpl.java b/java/com/android/dialer/contactphoto/ContactPhotoManagerImpl.java
new file mode 100644
index 000000000..5dbdf5e48
--- /dev/null
+++ b/java/com/android/dialer/contactphoto/ContactPhotoManagerImpl.java
@@ -0,0 +1,1266 @@
+/*
+ * Copyright (C) 2016 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.dialer.contactphoto;
+
+import android.app.ActivityManager;
+import android.content.ComponentCallbacks2;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.TransitionDrawable;
+import android.media.ThumbnailUtils;
+import android.net.TrafficStats;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Handler.Callback;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Contacts.Photo;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.Directory;
+import android.support.annotation.UiThread;
+import android.support.annotation.WorkerThread;
+import android.support.v4.graphics.drawable.RoundedBitmapDrawable;
+import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory;
+import android.text.TextUtils;
+import android.util.LruCache;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.constants.Constants;
+import com.android.dialer.constants.TrafficStatsTags;
+import com.android.dialer.util.PermissionsUtil;
+import com.android.dialer.util.UriUtils;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+class ContactPhotoManagerImpl extends ContactPhotoManager implements Callback {
+
+  private static final String LOADER_THREAD_NAME = "ContactPhotoLoader";
+
+  private static final int FADE_TRANSITION_DURATION = 200;
+
+  /**
+   * 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;
+
+  private static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+  private static final String[] COLUMNS = new String[] {Photo._ID, Photo.PHOTO};
+
+  /**
+   * Dummy object used to indicate that a bitmap for a given key could not be stored in the cache.
+   */
+  private static final BitmapHolder BITMAP_UNAVAILABLE;
+  /** Cache size for {@link #mBitmapHolderCache} for devices with "large" RAM. */
+  private static final int HOLDER_CACHE_SIZE = 2000000;
+  /** Cache size for {@link #mBitmapCache} for devices with "large" RAM. */
+  private static final int BITMAP_CACHE_SIZE = 36864 * 48; // 1728K
+  /** Height/width of a thumbnail image */
+  private static int mThumbnailSize;
+
+  static {
+    BITMAP_UNAVAILABLE = new BitmapHolder(new byte[0], 0);
+    BITMAP_UNAVAILABLE.bitmapRef = new SoftReference<Bitmap>(null);
+  }
+
+  private final Context mContext;
+  /**
+   * An LRU cache for bitmap holders. The cache contains bytes for photos just as they come from the
+   * database. Each holder has a soft reference to the actual bitmap.
+   */
+  private final LruCache<Object, BitmapHolder> mBitmapHolderCache;
+  /** Cache size threshold at which bitmaps will not be preloaded. */
+  private final int mBitmapHolderCacheRedZoneBytes;
+  /**
+   * Level 2 LRU cache for bitmaps. This is a smaller cache that holds the most recently used
+   * bitmaps to save time on decoding them from bytes (the bytes are stored in {@link
+   * #mBitmapHolderCache}.
+   */
+  private final LruCache<Object, Bitmap> mBitmapCache;
+  /**
+   * A map from ImageView to the corresponding photo ID or uri, encapsulated in a request. The
+   * request may swapped out before the photo loading request is started.
+   */
+  private final ConcurrentHashMap<ImageView, Request> mPendingRequests =
+      new ConcurrentHashMap<ImageView, Request>();
+  /** Handler for messages sent to the UI thread. */
+  private final Handler mMainThreadHandler = new Handler(this);
+  /** For debug: How many times we had to reload cached photo for a stale entry */
+  private final AtomicInteger mStaleCacheOverwrite = new AtomicInteger();
+  /** For debug: How many times we had to reload cached photo for a fresh entry. Should be 0. */
+  private final AtomicInteger mFreshCacheOverwrite = new AtomicInteger();
+  /** {@code true} if ALL entries in {@link #mBitmapHolderCache} are NOT fresh. */
+  private volatile boolean mBitmapHolderCacheAllUnfresh = true;
+  /** Thread responsible for loading photos from the database. Created upon the first request. */
+  private LoaderThread 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;
+  /** The user agent string to use when loading URI based photos. */
+  private String mUserAgent;
+
+  public ContactPhotoManagerImpl(Context context) {
+    mContext = context;
+
+    final ActivityManager am =
+        ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE));
+
+    final float cacheSizeAdjustment = (am.isLowRamDevice()) ? 0.5f : 1.0f;
+
+    final int bitmapCacheSize = (int) (cacheSizeAdjustment * BITMAP_CACHE_SIZE);
+    mBitmapCache =
+        new LruCache<Object, Bitmap>(bitmapCacheSize) {
+          @Override
+          protected int sizeOf(Object key, Bitmap value) {
+            return value.getByteCount();
+          }
+
+          @Override
+          protected void entryRemoved(
+              boolean evicted, Object key, Bitmap oldValue, Bitmap newValue) {
+            if (DEBUG) {
+              dumpStats();
+            }
+          }
+        };
+    final int holderCacheSize = (int) (cacheSizeAdjustment * HOLDER_CACHE_SIZE);
+    mBitmapHolderCache =
+        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();
+            }
+          }
+        };
+    mBitmapHolderCacheRedZoneBytes = (int) (holderCacheSize * 0.75);
+    LogUtil.i(
+        "ContactPhotoManagerImpl.ContactPhotoManagerImpl", "cache adj: " + cacheSizeAdjustment);
+    if (DEBUG) {
+      LogUtil.d(
+          "ContactPhotoManagerImpl.ContactPhotoManagerImpl",
+          "Cache size: " + btk(mBitmapHolderCache.maxSize()) + " + " + btk(mBitmapCache.maxSize()));
+    }
+
+    mThumbnailSize =
+        context.getResources().getDimensionPixelSize(R.dimen.contact_browser_list_item_photo_size);
+
+    // Get a user agent string to use for URI photo requests.
+    mUserAgent = Constants.get().getUserAgent(context);
+    if (mUserAgent == null) {
+      mUserAgent = "";
+    }
+  }
+
+  /** 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);
+  }
+
+  private static boolean isChildView(View parent, View potentialChild) {
+    return potentialChild.getParent() != null
+        && (potentialChild.getParent() == parent
+            || (potentialChild.getParent() instanceof ViewGroup
+                && isChildView(parent, (ViewGroup) potentialChild.getParent())));
+  }
+
+  /**
+   * If necessary, decodes bytes stored in the holder to Bitmap. As long as the bitmap is held
+   * either by {@link #mBitmapCache} or by a soft reference in the holder, it will not be necessary
+   * to decode the bitmap.
+   */
+  private static void inflateBitmap(BitmapHolder holder, int requestedExtent) {
+    final int sampleSize =
+        BitmapUtil.findOptimalSampleSize(holder.originalSmallerExtent, requestedExtent);
+    byte[] bytes = holder.bytes;
+    if (bytes == null || bytes.length == 0) {
+      return;
+    }
+
+    if (sampleSize == holder.decodedSampleSize) {
+      // Check the soft reference.  If will be retained if the bitmap is also
+      // in the LRU cache, so we don't need to check the LRU cache explicitly.
+      if (holder.bitmapRef != null) {
+        holder.bitmap = holder.bitmapRef.get();
+        if (holder.bitmap != null) {
+          return;
+        }
+      }
+    }
+
+    try {
+      Bitmap bitmap = BitmapUtil.decodeBitmapFromBytes(bytes, sampleSize);
+
+      // TODO: As a temporary workaround while framework support is being added to
+      // clip non-square bitmaps into a perfect circle, manually crop the bitmap into
+      // into a square if it will be displayed as a thumbnail so that it can be cropped
+      // into a circle.
+      final int height = bitmap.getHeight();
+      final int width = bitmap.getWidth();
+
+      // The smaller dimension of a scaled bitmap can range from anywhere from 0 to just
+      // below twice the length of a thumbnail image due to the way we calculate the optimal
+      // sample size.
+      if (height != width && Math.min(height, width) <= mThumbnailSize * 2) {
+        final int dimension = Math.min(height, width);
+        bitmap = ThumbnailUtils.extractThumbnail(bitmap, dimension, dimension);
+      }
+      // make bitmap mutable and draw size onto it
+      if (DEBUG_SIZES) {
+        Bitmap original = bitmap;
+        bitmap = bitmap.copy(bitmap.getConfig(), true);
+        original.recycle();
+        Canvas canvas = new Canvas(bitmap);
+        Paint paint = new Paint();
+        paint.setTextSize(16);
+        paint.setColor(Color.BLUE);
+        paint.setStyle(Style.FILL);
+        canvas.drawRect(0.0f, 0.0f, 50.0f, 20.0f, paint);
+        paint.setColor(Color.WHITE);
+        paint.setAntiAlias(true);
+        canvas.drawText(bitmap.getWidth() + "/" + sampleSize, 0, 15, paint);
+      }
+
+      holder.decodedSampleSize = sampleSize;
+      holder.bitmap = bitmap;
+      holder.bitmapRef = new SoftReference<Bitmap>(bitmap);
+      if (DEBUG) {
+        LogUtil.d(
+            "ContactPhotoManagerImpl.inflateBitmap",
+            "inflateBitmap "
+                + btk(bytes.length)
+                + " -> "
+                + bitmap.getWidth()
+                + "x"
+                + bitmap.getHeight()
+                + ", "
+                + btk(bitmap.getByteCount()));
+      }
+    } catch (OutOfMemoryError e) {
+      // Do nothing - the photo will appear to be missing
+    }
+  }
+
+  /** Dump cache stats on logcat. */
+  private void dumpStats() {
+    if (!DEBUG) {
+      return;
+    }
+    {
+      int numHolders = 0;
+      int rawBytes = 0;
+      int bitmapBytes = 0;
+      int numBitmaps = 0;
+      for (BitmapHolder h : mBitmapHolderCache.snapshot().values()) {
+        numHolders++;
+        if (h.bytes != null) {
+          rawBytes += h.bytes.length;
+        }
+        Bitmap b = h.bitmapRef != null ? h.bitmapRef.get() : null;
+        if (b != null) {
+          numBitmaps++;
+          bitmapBytes += b.getByteCount();
+        }
+      }
+      LogUtil.d(
+          "ContactPhotoManagerImpl.dumpStats",
+          "L1: "
+              + btk(rawBytes)
+              + " + "
+              + btk(bitmapBytes)
+              + " = "
+              + btk(rawBytes + bitmapBytes)
+              + ", "
+              + numHolders
+              + " holders, "
+              + numBitmaps
+              + " bitmaps, avg: "
+              + btk(safeDiv(rawBytes, numHolders))
+              + ","
+              + btk(safeDiv(bitmapBytes, numBitmaps)));
+      LogUtil.d(
+          "ContactPhotoManagerImpl.dumpStats",
+          "L1 Stats: "
+              + mBitmapHolderCache.toString()
+              + ", overwrite: fresh="
+              + mFreshCacheOverwrite.get()
+              + " stale="
+              + mStaleCacheOverwrite.get());
+    }
+
+    {
+      int numBitmaps = 0;
+      int bitmapBytes = 0;
+      for (Bitmap b : mBitmapCache.snapshot().values()) {
+        numBitmaps++;
+        bitmapBytes += b.getByteCount();
+      }
+      LogUtil.d(
+          "ContactPhotoManagerImpl.dumpStats",
+          "L2: "
+              + btk(bitmapBytes)
+              + ", "
+              + numBitmaps
+              + " bitmaps"
+              + ", avg: "
+              + btk(safeDiv(bitmapBytes, numBitmaps)));
+      // We don't get from L2 cache, so L2 stats is meaningless.
+    }
+  }
+
+  @Override
+  public void onTrimMemory(int level) {
+    if (DEBUG) {
+      LogUtil.d("ContactPhotoManagerImpl.onTrimMemory", "onTrimMemory: " + level);
+    }
+    if (level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
+      // Clear the caches.  Note all pending requests will be removed too.
+      clear();
+    }
+  }
+
+  @Override
+  public void preloadPhotosInBackground() {
+    ensureLoaderThread();
+    mLoaderThread.requestPreloading();
+  }
+
+  @Override
+  public void loadThumbnail(
+      ImageView view,
+      long photoId,
+      boolean darkTheme,
+      boolean isCircular,
+      DefaultImageRequest defaultImageRequest,
+      DefaultImageProvider defaultProvider) {
+    if (photoId == 0) {
+      // No photo is needed
+      defaultProvider.applyDefaultImage(view, -1, darkTheme, defaultImageRequest);
+      mPendingRequests.remove(view);
+    } else {
+      if (DEBUG) {
+        LogUtil.d("ContactPhotoManagerImpl.loadThumbnail", "loadPhoto request: " + photoId);
+      }
+      loadPhotoByIdOrUri(
+          view, Request.createFromThumbnailId(photoId, darkTheme, isCircular, defaultProvider));
+    }
+  }
+
+  @Override
+  public void loadPhoto(
+      ImageView view,
+      Uri photoUri,
+      int requestedExtent,
+      boolean darkTheme,
+      boolean isCircular,
+      DefaultImageRequest defaultImageRequest,
+      DefaultImageProvider defaultProvider) {
+    if (photoUri == null) {
+      // No photo is needed
+      defaultProvider.applyDefaultImage(view, requestedExtent, darkTheme, defaultImageRequest);
+      mPendingRequests.remove(view);
+    } else {
+      if (DEBUG) {
+        LogUtil.d("ContactPhotoManagerImpl.loadPhoto", "loadPhoto request: " + photoUri);
+      }
+      if (isDefaultImageUri(photoUri)) {
+        createAndApplyDefaultImageForUri(
+            view, photoUri, requestedExtent, darkTheme, isCircular, defaultProvider);
+      } else {
+        loadPhotoByIdOrUri(
+            view,
+            Request.createFromUri(
+                photoUri, requestedExtent, darkTheme, isCircular, defaultProvider));
+      }
+    }
+  }
+
+  private void createAndApplyDefaultImageForUri(
+      ImageView view,
+      Uri uri,
+      int requestedExtent,
+      boolean darkTheme,
+      boolean isCircular,
+      DefaultImageProvider defaultProvider) {
+    DefaultImageRequest request = getDefaultImageRequestFromUri(uri);
+    request.isCircular = isCircular;
+    defaultProvider.applyDefaultImage(view, requestedExtent, darkTheme, request);
+  }
+
+  private void loadPhotoByIdOrUri(ImageView view, Request request) {
+    boolean loaded = loadCachedPhoto(view, request, false);
+    if (loaded) {
+      mPendingRequests.remove(view);
+    } else {
+      mPendingRequests.put(view, request);
+      if (!mPaused) {
+        // Send a request to start loading photos
+        requestLoading();
+      }
+    }
+  }
+
+  @Override
+  public void removePhoto(ImageView view) {
+    view.setImageDrawable(null);
+    mPendingRequests.remove(view);
+  }
+
+  /**
+   * Cancels pending requests to load photos asynchronously for views inside {@param
+   * fragmentRootView}. If {@param fragmentRootView} is null, cancels all requests.
+   */
+  @Override
+  public void cancelPendingRequests(View fragmentRootView) {
+    if (fragmentRootView == null) {
+      mPendingRequests.clear();
+      return;
+    }
+    final Iterator<Entry<ImageView, Request>> iterator = mPendingRequests.entrySet().iterator();
+    while (iterator.hasNext()) {
+      final ImageView imageView = iterator.next().getKey();
+      // If an ImageView is orphaned (currently scrap) or a child of fragmentRootView, then
+      // we can safely remove its request.
+      if (imageView.getParent() == null || isChildView(fragmentRootView, imageView)) {
+        iterator.remove();
+      }
+    }
+  }
+
+  @Override
+  public void refreshCache() {
+    if (mBitmapHolderCacheAllUnfresh) {
+      if (DEBUG) {
+        LogUtil.d("ContactPhotoManagerImpl.refreshCache", "refreshCache -- no fresh entries.");
+      }
+      return;
+    }
+    if (DEBUG) {
+      LogUtil.d("ContactPhotoManagerImpl.refreshCache", "refreshCache");
+    }
+    mBitmapHolderCacheAllUnfresh = true;
+    for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
+      if (holder != BITMAP_UNAVAILABLE) {
+        holder.fresh = false;
+      }
+    }
+  }
+
+  /**
+   * Checks if the photo is present in cache. If so, sets the photo on the view.
+   *
+   * @return false if the photo needs to be (re)loaded from the provider.
+   */
+  @UiThread
+  private boolean loadCachedPhoto(ImageView view, Request request, boolean fadeIn) {
+    BitmapHolder holder = mBitmapHolderCache.get(request.getKey());
+    if (holder == null) {
+      // The bitmap has not been loaded ==> show default avatar
+      request.applyDefaultImage(view, request.mIsCircular);
+      return false;
+    }
+
+    if (holder.bytes == null) {
+      request.applyDefaultImage(view, request.mIsCircular);
+      return holder.fresh;
+    }
+
+    Bitmap cachedBitmap = holder.bitmapRef == null ? null : holder.bitmapRef.get();
+    if (cachedBitmap == null) {
+      request.applyDefaultImage(view, request.mIsCircular);
+      return false;
+    }
+
+    final Drawable previousDrawable = view.getDrawable();
+    if (fadeIn && previousDrawable != null) {
+      final Drawable[] layers = new Drawable[2];
+      // Prevent cascade of TransitionDrawables.
+      if (previousDrawable instanceof TransitionDrawable) {
+        final TransitionDrawable previousTransitionDrawable = (TransitionDrawable) previousDrawable;
+        layers[0] =
+            previousTransitionDrawable.getDrawable(
+                previousTransitionDrawable.getNumberOfLayers() - 1);
+      } else {
+        layers[0] = previousDrawable;
+      }
+      layers[1] = getDrawableForBitmap(mContext.getResources(), cachedBitmap, request);
+      TransitionDrawable drawable = new TransitionDrawable(layers);
+      view.setImageDrawable(drawable);
+      drawable.startTransition(FADE_TRANSITION_DURATION);
+    } else {
+      view.setImageDrawable(getDrawableForBitmap(mContext.getResources(), cachedBitmap, request));
+    }
+
+    // Put the bitmap in the LRU cache. But only do this for images that are small enough
+    // (we require that at least six of those can be cached at the same time)
+    if (cachedBitmap.getByteCount() < mBitmapCache.maxSize() / 6) {
+      mBitmapCache.put(request.getKey(), cachedBitmap);
+    }
+
+    // Soften the reference
+    holder.bitmap = null;
+
+    return holder.fresh;
+  }
+
+  /**
+   * Given a bitmap, returns a drawable that is configured to display the bitmap based on the
+   * specified request.
+   */
+  private Drawable getDrawableForBitmap(Resources resources, Bitmap bitmap, Request request) {
+    if (request.mIsCircular) {
+      final RoundedBitmapDrawable drawable = RoundedBitmapDrawableFactory.create(resources, bitmap);
+      drawable.setAntiAlias(true);
+      drawable.setCornerRadius(drawable.getIntrinsicHeight() / 2);
+      return drawable;
+    } else {
+      return new BitmapDrawable(resources, bitmap);
+    }
+  }
+
+  public void clear() {
+    if (DEBUG) {
+      LogUtil.d("ContactPhotoManagerImpl.clear", "clear");
+    }
+    mPendingRequests.clear();
+    mBitmapHolderCache.evictAll();
+    mBitmapCache.evictAll();
+  }
+
+  @Override
+  public void pause() {
+    mPaused = true;
+  }
+
+  @Override
+  public void resume() {
+    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(Message msg) {
+    switch (msg.what) {
+      case MESSAGE_REQUEST_LOADING:
+        {
+          mLoadingRequested = false;
+          if (!mPaused) {
+            ensureLoaderThread();
+            mLoaderThread.requestLoading();
+          }
+          return true;
+        }
+
+      case MESSAGE_PHOTOS_LOADED:
+        {
+          if (!mPaused) {
+            processLoadedImages();
+          }
+          if (DEBUG) {
+            dumpStats();
+          }
+          return true;
+        }
+      default:
+        return false;
+    }
+  }
+
+  public void ensureLoaderThread() {
+    if (mLoaderThread == null) {
+      mLoaderThread = new LoaderThread(mContext.getContentResolver());
+      mLoaderThread.start();
+    }
+  }
+
+  /**
+   * Goes over pending loading requests and displays loaded photos. If some of the photos still
+   * haven't been loaded, sends another request for image loading.
+   */
+  private void processLoadedImages() {
+    final Iterator<Entry<ImageView, Request>> iterator = mPendingRequests.entrySet().iterator();
+    while (iterator.hasNext()) {
+      final Entry<ImageView, Request> entry = iterator.next();
+      // TODO: Temporarily disable contact photo fading in, until issues with
+      // RoundedBitmapDrawables overlapping the default image drawables are resolved.
+      final boolean loaded = loadCachedPhoto(entry.getKey(), entry.getValue(), false);
+      if (loaded) {
+        iterator.remove();
+      }
+    }
+
+    softenCache();
+
+    if (!mPendingRequests.isEmpty()) {
+      requestLoading();
+    }
+  }
+
+  /**
+   * Removes strong references to loaded bitmaps to allow them to be garbage collected if needed.
+   * Some of the bitmaps will still be retained by {@link #mBitmapCache}.
+   */
+  private void softenCache() {
+    for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) {
+      holder.bitmap = null;
+    }
+  }
+
+  /** Stores the supplied bitmap in cache. */
+  private void cacheBitmap(Object key, byte[] bytes, boolean preloading, int requestedExtent) {
+    if (DEBUG) {
+      BitmapHolder prev = mBitmapHolderCache.get(key);
+      if (prev != null && prev.bytes != null) {
+        LogUtil.d(
+            "ContactPhotoManagerImpl.cacheBitmap",
+            "overwriting cache: key=" + key + (prev.fresh ? " FRESH" : " stale"));
+        if (prev.fresh) {
+          mFreshCacheOverwrite.incrementAndGet();
+        } else {
+          mStaleCacheOverwrite.incrementAndGet();
+        }
+      }
+      LogUtil.d(
+          "ContactPhotoManagerImpl.cacheBitmap",
+          "caching data: key=" + key + ", " + (bytes == null ? "<null>" : btk(bytes.length)));
+    }
+    BitmapHolder holder =
+        new BitmapHolder(bytes, bytes == null ? -1 : BitmapUtil.getSmallerExtentFromBytes(bytes));
+
+    // Unless this image is being preloaded, decode it right away while
+    // we are still on the background thread.
+    if (!preloading) {
+      inflateBitmap(holder, requestedExtent);
+    }
+
+    if (bytes != null) {
+      mBitmapHolderCache.put(key, holder);
+      if (mBitmapHolderCache.get(key) != holder) {
+        LogUtil.w("ContactPhotoManagerImpl.cacheBitmap", "bitmap too big to fit in cache.");
+        mBitmapHolderCache.put(key, BITMAP_UNAVAILABLE);
+      }
+    } else {
+      mBitmapHolderCache.put(key, BITMAP_UNAVAILABLE);
+    }
+
+    mBitmapHolderCacheAllUnfresh = false;
+  }
+
+  /**
+   * Populates an array of photo IDs that need to be loaded. Also decodes bitmaps that we have
+   * already loaded
+   */
+  private void obtainPhotoIdsAndUrisToLoad(
+      Set<Long> photoIds, Set<String> photoIdsAsStrings, Set<Request> uris) {
+    photoIds.clear();
+    photoIdsAsStrings.clear();
+    uris.clear();
+
+    boolean jpegsDecoded = false;
+
+    /*
+     * Since the call is made from the loader thread, the map could be
+     * changing during the iteration. That's not really a problem:
+     * ConcurrentHashMap will allow those changes to happen without throwing
+     * exceptions. Since we may miss some requests in the situation of
+     * concurrent change, we will need to check the map again once loading
+     * is complete.
+     */
+    Iterator<Request> iterator = mPendingRequests.values().iterator();
+    while (iterator.hasNext()) {
+      Request request = iterator.next();
+      final BitmapHolder holder = mBitmapHolderCache.get(request.getKey());
+      if (holder == BITMAP_UNAVAILABLE) {
+        continue;
+      }
+      if (holder != null
+          && holder.bytes != null
+          && holder.fresh
+          && (holder.bitmapRef == null || holder.bitmapRef.get() == null)) {
+        // This was previously loaded but we don't currently have the inflated Bitmap
+        inflateBitmap(holder, request.getRequestedExtent());
+        jpegsDecoded = true;
+      } else {
+        if (holder == null || !holder.fresh) {
+          if (request.isUriRequest()) {
+            uris.add(request);
+          } else {
+            photoIds.add(request.getId());
+            photoIdsAsStrings.add(String.valueOf(request.mId));
+          }
+        }
+      }
+    }
+
+    if (jpegsDecoded) {
+      mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
+    }
+  }
+
+  /** Maintains the state of a particular photo. */
+  private static class BitmapHolder {
+
+    final byte[] bytes;
+    final int originalSmallerExtent;
+
+    volatile boolean fresh;
+    Bitmap bitmap;
+    Reference<Bitmap> bitmapRef;
+    int decodedSampleSize;
+
+    public BitmapHolder(byte[] bytes, int originalSmallerExtent) {
+      this.bytes = bytes;
+      this.fresh = true;
+      this.originalSmallerExtent = originalSmallerExtent;
+    }
+  }
+
+  /**
+   * A holder for either a Uri or an id and a flag whether this was requested for the dark or light
+   * theme
+   */
+  private static final class Request {
+
+    private final long mId;
+    private final Uri mUri;
+    private final boolean mDarkTheme;
+    private final int mRequestedExtent;
+    private final DefaultImageProvider mDefaultProvider;
+    /** Whether or not the contact photo is to be displayed as a circle */
+    private final boolean mIsCircular;
+
+    private Request(
+        long id,
+        Uri uri,
+        int requestedExtent,
+        boolean darkTheme,
+        boolean isCircular,
+        DefaultImageProvider defaultProvider) {
+      mId = id;
+      mUri = uri;
+      mDarkTheme = darkTheme;
+      mIsCircular = isCircular;
+      mRequestedExtent = requestedExtent;
+      mDefaultProvider = defaultProvider;
+    }
+
+    public static Request createFromThumbnailId(
+        long id, boolean darkTheme, boolean isCircular, DefaultImageProvider defaultProvider) {
+      return new Request(id, null /* no URI */, -1, darkTheme, isCircular, defaultProvider);
+    }
+
+    public static Request createFromUri(
+        Uri uri,
+        int requestedExtent,
+        boolean darkTheme,
+        boolean isCircular,
+        DefaultImageProvider defaultProvider) {
+      return new Request(
+          0 /* no ID */, uri, requestedExtent, darkTheme, isCircular, defaultProvider);
+    }
+
+    public boolean isUriRequest() {
+      return mUri != null;
+    }
+
+    public Uri getUri() {
+      return mUri;
+    }
+
+    public long getId() {
+      return mId;
+    }
+
+    public int getRequestedExtent() {
+      return mRequestedExtent;
+    }
+
+    @Override
+    public int hashCode() {
+      final int prime = 31;
+      int result = 1;
+      result = prime * result + (int) (mId ^ (mId >>> 32));
+      result = prime * result + mRequestedExtent;
+      result = prime * result + ((mUri == null) ? 0 : mUri.hashCode());
+      return result;
+    }
+
+    @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 (mId != that.mId) {
+        return false;
+      }
+      if (mRequestedExtent != that.mRequestedExtent) {
+        return false;
+      }
+      if (!UriUtils.areEqual(mUri, that.mUri)) {
+        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;
+    }
+
+    public Object getKey() {
+      return mUri == null ? mId : mUri;
+    }
+
+    /**
+     * Applies the default image to the current view. If the request is URI-based, looks for the
+     * contact type encoded fragment to determine if this is a request for a business photo, in
+     * which case we will load the default business photo.
+     *
+     * @param view The current image view to apply the image to.
+     * @param isCircular Whether the image is circular or not.
+     */
+    public void applyDefaultImage(ImageView view, boolean isCircular) {
+      final DefaultImageRequest request;
+
+      if (isCircular) {
+        request =
+            ContactPhotoManager.isBusinessContactUri(mUri)
+                ? DefaultImageRequest.EMPTY_CIRCULAR_BUSINESS_IMAGE_REQUEST
+                : DefaultImageRequest.EMPTY_CIRCULAR_DEFAULT_IMAGE_REQUEST;
+      } else {
+        request =
+            ContactPhotoManager.isBusinessContactUri(mUri)
+                ? DefaultImageRequest.EMPTY_DEFAULT_BUSINESS_IMAGE_REQUEST
+                : DefaultImageRequest.EMPTY_DEFAULT_IMAGE_REQUEST;
+      }
+      mDefaultProvider.applyDefaultImage(view, mRequestedExtent, mDarkTheme, request);
+    }
+  }
+
+  /** The thread that performs loading of photos from the database. */
+  private class LoaderThread extends HandlerThread implements Callback {
+
+    private static final int BUFFER_SIZE = 1024 * 16;
+    private static final int MESSAGE_PRELOAD_PHOTOS = 0;
+    private static final int MESSAGE_LOAD_PHOTOS = 1;
+
+    /** A pause between preload batches that yields to the UI thread. */
+    private static final int PHOTO_PRELOAD_DELAY = 1000;
+
+    /** Number of photos to preload per batch. */
+    private static final int PRELOAD_BATCH = 25;
+
+    /**
+     * Maximum number of photos to preload. If the cache size is 2Mb and the expected average size
+     * of a photo is 4kb, then this number should be 2Mb/4kb = 500.
+     */
+    private static final int MAX_PHOTOS_TO_PRELOAD = 100;
+
+    private static final int PRELOAD_STATUS_NOT_STARTED = 0;
+    private static final int PRELOAD_STATUS_IN_PROGRESS = 1;
+    private static final int PRELOAD_STATUS_DONE = 2;
+    private final ContentResolver mResolver;
+    private final StringBuilder mStringBuilder = new StringBuilder();
+    private final Set<Long> mPhotoIds = new HashSet<>();
+    private final Set<String> mPhotoIdsAsStrings = new HashSet<>();
+    private final Set<Request> mPhotoUris = new HashSet<>();
+    private final List<Long> mPreloadPhotoIds = new ArrayList<>();
+    private Handler mLoaderThreadHandler;
+    private byte[] mBuffer;
+    private int mPreloadStatus = PRELOAD_STATUS_NOT_STARTED;
+
+    public LoaderThread(ContentResolver resolver) {
+      super(LOADER_THREAD_NAME);
+      mResolver = resolver;
+    }
+
+    public void ensureHandler() {
+      if (mLoaderThreadHandler == null) {
+        mLoaderThreadHandler = new Handler(getLooper(), this);
+      }
+    }
+
+    /**
+     * Kicks off preloading of the next batch of photos on the background thread. Preloading will
+     * happen after a delay: we want to yield to the UI thread as much as possible.
+     *
+     * <p>If preloading is already complete, does nothing.
+     */
+    public void requestPreloading() {
+      if (mPreloadStatus == PRELOAD_STATUS_DONE) {
+        return;
+      }
+
+      ensureHandler();
+      if (mLoaderThreadHandler.hasMessages(MESSAGE_LOAD_PHOTOS)) {
+        return;
+      }
+
+      mLoaderThreadHandler.sendEmptyMessageDelayed(MESSAGE_PRELOAD_PHOTOS, PHOTO_PRELOAD_DELAY);
+    }
+
+    /**
+     * Sends a message to this thread to load requested photos. Cancels a preloading request, if
+     * any: we don't want preloading to impede loading of the photos we need to display now.
+     */
+    public void requestLoading() {
+      ensureHandler();
+      mLoaderThreadHandler.removeMessages(MESSAGE_PRELOAD_PHOTOS);
+      mLoaderThreadHandler.sendEmptyMessage(MESSAGE_LOAD_PHOTOS);
+    }
+
+    /**
+     * 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_PRELOAD_PHOTOS:
+          preloadPhotosInBackground();
+          break;
+        case MESSAGE_LOAD_PHOTOS:
+          loadPhotosInBackground();
+          break;
+      }
+      return true;
+    }
+
+    /**
+     * The first time it is called, figures out which photos need to be preloaded. Each subsequent
+     * call preloads the next batch of photos and requests another cycle of preloading after a
+     * delay. The whole process ends when we either run out of photos to preload or fill up cache.
+     */
+    @WorkerThread
+    private void preloadPhotosInBackground() {
+      if (!PermissionsUtil.hasPermission(mContext, android.Manifest.permission.READ_CONTACTS)) {
+        return;
+      }
+
+      if (mPreloadStatus == PRELOAD_STATUS_DONE) {
+        return;
+      }
+
+      if (mPreloadStatus == PRELOAD_STATUS_NOT_STARTED) {
+        queryPhotosForPreload();
+        if (mPreloadPhotoIds.isEmpty()) {
+          mPreloadStatus = PRELOAD_STATUS_DONE;
+        } else {
+          mPreloadStatus = PRELOAD_STATUS_IN_PROGRESS;
+        }
+        requestPreloading();
+        return;
+      }
+
+      if (mBitmapHolderCache.size() > mBitmapHolderCacheRedZoneBytes) {
+        mPreloadStatus = PRELOAD_STATUS_DONE;
+        return;
+      }
+
+      mPhotoIds.clear();
+      mPhotoIdsAsStrings.clear();
+
+      int count = 0;
+      int preloadSize = mPreloadPhotoIds.size();
+      while (preloadSize > 0 && mPhotoIds.size() < PRELOAD_BATCH) {
+        preloadSize--;
+        count++;
+        Long photoId = mPreloadPhotoIds.get(preloadSize);
+        mPhotoIds.add(photoId);
+        mPhotoIdsAsStrings.add(photoId.toString());
+        mPreloadPhotoIds.remove(preloadSize);
+      }
+
+      loadThumbnails(true);
+
+      if (preloadSize == 0) {
+        mPreloadStatus = PRELOAD_STATUS_DONE;
+      }
+
+      LogUtil.v(
+          "ContactPhotoManagerImpl.preloadPhotosInBackground",
+          "preloaded " + count + " photos.  cached bytes: " + mBitmapHolderCache.size());
+
+      requestPreloading();
+    }
+
+    @WorkerThread
+    private void queryPhotosForPreload() {
+      Cursor cursor = null;
+      try {
+        Uri uri =
+            Contacts.CONTENT_URI
+                .buildUpon()
+                .appendQueryParameter(
+                    ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(Directory.DEFAULT))
+                .appendQueryParameter(
+                    ContactsContract.LIMIT_PARAM_KEY, String.valueOf(MAX_PHOTOS_TO_PRELOAD))
+                .build();
+        cursor =
+            mResolver.query(
+                uri,
+                new String[] {Contacts.PHOTO_ID},
+                Contacts.PHOTO_ID + " NOT NULL AND " + Contacts.PHOTO_ID + "!=0",
+                null,
+                Contacts.STARRED + " DESC, " + Contacts.LAST_TIME_CONTACTED + " DESC");
+
+        if (cursor != null) {
+          while (cursor.moveToNext()) {
+            // Insert them in reverse order, because we will be taking
+            // them from the end of the list for loading.
+            mPreloadPhotoIds.add(0, cursor.getLong(0));
+          }
+        }
+      } finally {
+        if (cursor != null) {
+          cursor.close();
+        }
+      }
+    }
+
+    @WorkerThread
+    private void loadPhotosInBackground() {
+      if (!PermissionsUtil.hasPermission(mContext, android.Manifest.permission.READ_CONTACTS)) {
+        return;
+      }
+      obtainPhotoIdsAndUrisToLoad(mPhotoIds, mPhotoIdsAsStrings, mPhotoUris);
+      loadThumbnails(false);
+      loadUriBasedPhotos();
+      requestPreloading();
+    }
+
+    /** Loads thumbnail photos with ids */
+    @WorkerThread
+    private void loadThumbnails(boolean preloading) {
+      if (mPhotoIds.isEmpty()) {
+        return;
+      }
+
+      // Remove loaded photos from the preload queue: we don't want
+      // the preloading process to load them again.
+      if (!preloading && mPreloadStatus == PRELOAD_STATUS_IN_PROGRESS) {
+        for (Long id : mPhotoIds) {
+          mPreloadPhotoIds.remove(id);
+        }
+        if (mPreloadPhotoIds.isEmpty()) {
+          mPreloadStatus = PRELOAD_STATUS_DONE;
+        }
+      }
+
+      mStringBuilder.setLength(0);
+      mStringBuilder.append(Photo._ID + " IN(");
+      for (int i = 0; i < mPhotoIds.size(); i++) {
+        if (i != 0) {
+          mStringBuilder.append(',');
+        }
+        mStringBuilder.append('?');
+      }
+      mStringBuilder.append(')');
+
+      Cursor cursor = null;
+      try {
+        if (DEBUG) {
+          LogUtil.d(
+              "ContactPhotoManagerImpl.loadThumbnails",
+              "loading " + TextUtils.join(",", mPhotoIdsAsStrings));
+        }
+        cursor =
+            mResolver.query(
+                Data.CONTENT_URI,
+                COLUMNS,
+                mStringBuilder.toString(),
+                mPhotoIdsAsStrings.toArray(EMPTY_STRING_ARRAY),
+                null);
+
+        if (cursor != null) {
+          while (cursor.moveToNext()) {
+            Long id = cursor.getLong(0);
+            byte[] bytes = cursor.getBlob(1);
+            cacheBitmap(id, bytes, preloading, -1);
+            mPhotoIds.remove(id);
+          }
+        }
+      } finally {
+        if (cursor != null) {
+          cursor.close();
+        }
+      }
+
+      // Remaining photos were not found in the contacts database (but might be in profile).
+      for (Long id : mPhotoIds) {
+        if (ContactsContract.isProfileId(id)) {
+          Cursor profileCursor = null;
+          try {
+            profileCursor =
+                mResolver.query(
+                    ContentUris.withAppendedId(Data.CONTENT_URI, id), COLUMNS, null, null, null);
+            if (profileCursor != null && profileCursor.moveToFirst()) {
+              cacheBitmap(profileCursor.getLong(0), profileCursor.getBlob(1), preloading, -1);
+            } else {
+              // Couldn't load a photo this way either.
+              cacheBitmap(id, null, preloading, -1);
+            }
+          } finally {
+            if (profileCursor != null) {
+              profileCursor.close();
+            }
+          }
+        } else {
+          // Not a profile photo and not found - mark the cache accordingly
+          cacheBitmap(id, null, preloading, -1);
+        }
+      }
+
+      mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
+    }
+
+    /**
+     * Loads photos referenced with Uris. Those can be remote thumbnails (from directory searches),
+     * display photos etc
+     */
+    @WorkerThread
+    private void loadUriBasedPhotos() {
+      for (Request uriRequest : mPhotoUris) {
+        // Keep the original URI and use this to key into the cache.  Failure to do so will
+        // result in an image being continually reloaded into cache if the original URI
+        // has a contact type encodedFragment (eg nearby places business photo URLs).
+        Uri originalUri = uriRequest.getUri();
+
+        // Strip off the "contact type" we added to the URI to ensure it was identifiable as
+        // a business photo -- there is no need to pass this on to the server.
+        Uri uri = ContactPhotoManager.removeContactType(originalUri);
+
+        if (mBuffer == null) {
+          mBuffer = new byte[BUFFER_SIZE];
+        }
+        try {
+          if (DEBUG) {
+            LogUtil.d("ContactPhotoManagerImpl.loadUriBasedPhotos", "loading " + uri);
+          }
+          final String scheme = uri.getScheme();
+          InputStream is = null;
+          if (scheme.equals("http") || scheme.equals("https")) {
+            TrafficStats.setThreadStatsTag(TrafficStatsTags.CONTACT_PHOTO_DOWNLOAD_TAG);
+            try {
+              final HttpURLConnection connection =
+                  (HttpURLConnection) new URL(uri.toString()).openConnection();
+
+              // Include the user agent if it is specified.
+              if (!TextUtils.isEmpty(mUserAgent)) {
+                connection.setRequestProperty("User-Agent", mUserAgent);
+              }
+              try {
+                is = connection.getInputStream();
+              } catch (IOException e) {
+                connection.disconnect();
+                is = null;
+              }
+            } finally {
+              TrafficStats.clearThreadStatsTag();
+            }
+          } else {
+            is = mResolver.openInputStream(uri);
+          }
+          if (is != null) {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            try {
+              int size;
+              while ((size = is.read(mBuffer)) != -1) {
+                baos.write(mBuffer, 0, size);
+              }
+            } finally {
+              is.close();
+            }
+            cacheBitmap(originalUri, baos.toByteArray(), false, uriRequest.getRequestedExtent());
+            mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED);
+          } else {
+            LogUtil.v("ContactPhotoManagerImpl.loadUriBasedPhotos", "cannot load photo " + uri);
+            cacheBitmap(originalUri, null, false, uriRequest.getRequestedExtent());
+          }
+        } catch (final Exception | OutOfMemoryError ex) {
+          LogUtil.v("ContactPhotoManagerImpl.loadUriBasedPhotos", "cannot load photo " + uri, ex);
+          cacheBitmap(originalUri, null, false, uriRequest.getRequestedExtent());
+        }
+      }
+    }
+  }
+}