dialer/contactphoto/ContactPhotoManagerImpl.java

/*
 * 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 #bitmapHolderCache} for devices with "large" RAM. */
  private static final int HOLDER_CACHE_SIZE = 2000000;
  /** Cache size for {@link #bitmapCache} for devices with "large" RAM. */
  private static final int BITMAP_CACHE_SIZE = 36864 * 48; // 1728K
  /** Height/width of a thumbnail image */
  private static int thumbnailSize;

  static {
    BITMAP_UNAVAILABLE = new BitmapHolder(new byte[0], 0);
    BITMAP_UNAVAILABLE.bitmapRef = new SoftReference<Bitmap>(null);
  }

  private final Context context;
  /**
   * 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> bitmapHolderCache;
  /** Cache size threshold at which bitmaps will not be preloaded. */
  private final int bitmapHolderCacheRedZoneBytes;
  /**
   * 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
   * #bitmapHolderCache}.
   */
  private final LruCache<Object, Bitmap> bitmapCache;
  /**
   * 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> pendingRequests =
      new ConcurrentHashMap<ImageView, Request>();
  /** Handler for messages sent to the UI thread. */
  private final Handler mainThreadHandler = new Handler(this);
  /** For debug: How many times we had to reload cached photo for a stale entry */
  private final AtomicInteger staleCacheOverwrite = new AtomicInteger();
  /** For debug: How many times we had to reload cached photo for a fresh entry. Should be 0. */
  private final AtomicInteger freshCacheOverwrite = new AtomicInteger();
  /** {@code true} if ALL entries in {@link #bitmapHolderCache} are NOT fresh. */
  private volatile boolean bitmapHolderCacheAllUnfresh = true;
  /** Thread responsible for loading photos from the database. Created upon the first request. */
  private LoaderThread loaderThread;
  /** A gate to make sure we only send one instance of MESSAGE_PHOTOS_NEEDED at a time. */
  private boolean loadingRequested;
  /** Flag indicating if the image loading is paused. */
  private boolean paused;
  /** The user agent string to use when loading URI based photos. */
  private String userAgent;

  public ContactPhotoManagerImpl(Context context) {
    this.context = 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);
    bitmapCache =
        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);
    bitmapHolderCache =
        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();
            }
          }
        };
    bitmapHolderCacheRedZoneBytes = (int) (holderCacheSize * 0.75);
    LogUtil.i(
        "ContactPhotoManagerImpl.ContactPhotoManagerImpl", "cache adj: " + cacheSizeAdjustment);
    if (DEBUG) {
      LogUtil.d(
          "ContactPhotoManagerImpl.ContactPhotoManagerImpl",
          "Cache size: " + btk(bitmapHolderCache.maxSize()) + " + " + btk(bitmapCache.maxSize()));
    }

    thumbnailSize =
        context.getResources().getDimensionPixelSize(R.dimen.contact_browser_list_item_photo_size);

    // Get a user agent string to use for URI photo requests.
    userAgent = Constants.get().getUserAgent(context);
    if (userAgent == null) {
      userAgent = "";
    }
  }

  /** 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 #bitmapCache} 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) <= thumbnailSize * 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 : bitmapHolderCache.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: "
              + bitmapHolderCache.toString()
              + ", overwrite: fresh="
              + freshCacheOverwrite.get()
              + " stale="
              + staleCacheOverwrite.get());
    }

    {
      int numBitmaps = 0;
      int bitmapBytes = 0;
      for (Bitmap b : bitmapCache.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();
    loaderThread.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);
      pendingRequests.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);
      pendingRequests.remove(view);
      return;
    }
    if (isDrawableUri(photoUri)) {
      view.setImageURI(photoUri);
      pendingRequests.remove(view);
      return;
    }
    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 static boolean isDrawableUri(Uri uri) {
    if (!ContentResolver.SCHEME_ANDROID_RESOURCE.equals(uri.getScheme())) {
      return false;
    }
    return uri.getPathSegments().get(0).equals("drawable");
  }

  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) {
      pendingRequests.remove(view);
    } else {
      pendingRequests.put(view, request);
      if (!paused) {
        // Send a request to start loading photos
        requestLoading();
      }
    }
  }

  @Override
  public void removePhoto(ImageView view) {
    view.setImageDrawable(null);
    pendingRequests.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) {
      pendingRequests.clear();
      return;
    }
    final Iterator<Entry<ImageView, Request>> iterator = pendingRequests.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 (bitmapHolderCacheAllUnfresh) {
      if (DEBUG) {
        LogUtil.d("ContactPhotoManagerImpl.refreshCache", "refreshCache -- no fresh entries.");
      }
      return;
    }
    if (DEBUG) {
      LogUtil.d("ContactPhotoManagerImpl.refreshCache", "refreshCache");
    }
    bitmapHolderCacheAllUnfresh = true;
    for (BitmapHolder holder : bitmapHolderCache.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 = bitmapHolderCache.get(request.getKey());
    if (holder == null) {
      // The bitmap has not been loaded ==> show default avatar
      request.applyDefaultImage(view, request.isCircular);
      return false;
    }

    if (holder.bytes == null) {
      request.applyDefaultImage(view, request.isCircular);
      return holder.fresh;
    }

    Bitmap cachedBitmap = holder.bitmapRef == null ? null : holder.bitmapRef.get();
    if (cachedBitmap == null) {
      request.applyDefaultImage(view, request.isCircular);
      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(context.getResources(), cachedBitmap, request);
      TransitionDrawable drawable = new TransitionDrawable(layers);
      view.setImageDrawable(drawable);
      drawable.startTransition(FADE_TRANSITION_DURATION);
    } else {
      view.setImageDrawable(getDrawableForBitmap(context.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() < bitmapCache.maxSize() / 6) {
      bitmapCache.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.isCircular) {
      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");
    }
    pendingRequests.clear();
    bitmapHolderCache.evictAll();
    bitmapCache.evictAll();
  }

  @Override
  public void pause() {
    paused = true;
  }

  @Override
  public void resume() {
    paused = false;
    if (DEBUG) {
      dumpStats();
    }
    if (!pendingRequests.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 (!loadingRequested) {
      loadingRequested = true;
      mainThreadHandler.sendEmptyMessage(MESSAGE_REQUEST_LOADING);
    }
  }

  /** Processes requests on the main thread. */
  @Override
  public boolean handleMessage(Message msg) {
    switch (msg.what) {
      case MESSAGE_REQUEST_LOADING:
        {
          loadingRequested = false;
          if (!paused) {
            ensureLoaderThread();
            loaderThread.requestLoading();
          }
          return true;
        }

      case MESSAGE_PHOTOS_LOADED:
        {
          if (!paused) {
            processLoadedImages();
          }
          if (DEBUG) {
            dumpStats();
          }
          return true;
        }
      default:
        return false;
    }
  }

  public void ensureLoaderThread() {
    if (loaderThread == null) {
      loaderThread = new LoaderThread(context.getContentResolver());
      loaderThread.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 = pendingRequests.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 (!pendingRequests.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 #bitmapCache}.
   */
  private void softenCache() {
    for (BitmapHolder holder : bitmapHolderCache.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 = bitmapHolderCache.get(key);
      if (prev != null && prev.bytes != null) {
        LogUtil.d(
            "ContactPhotoManagerImpl.cacheBitmap",
            "overwriting cache: key=" + key + (prev.fresh ? " FRESH" : " stale"));
        if (prev.fresh) {
          freshCacheOverwrite.incrementAndGet();
        } else {
          staleCacheOverwrite.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) {
      bitmapHolderCache.put(key, holder);
      if (bitmapHolderCache.get(key) != holder) {
        LogUtil.w("ContactPhotoManagerImpl.cacheBitmap", "bitmap too big to fit in cache.");
        bitmapHolderCache.put(key, BITMAP_UNAVAILABLE);
      }
    } else {
      bitmapHolderCache.put(key, BITMAP_UNAVAILABLE);
    }

    bitmapHolderCacheAllUnfresh = 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 = pendingRequests.values().iterator();
    while (iterator.hasNext()) {
      Request request = iterator.next();
      final BitmapHolder holder = bitmapHolderCache.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.id));
          }
        }
      }
    }

    if (jpegsDecoded) {
      mainThreadHandler.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 id;
    private final Uri uri;
    private final boolean darkTheme;
    private final int requestedExtent;
    private final DefaultImageProvider defaultProvider;
    /** Whether or not the contact photo is to be displayed as a circle */
    private final boolean isCircular;

    private Request(
        long id,
        Uri uri,
        int requestedExtent,
        boolean darkTheme,
        boolean isCircular,
        DefaultImageProvider defaultProvider) {
      this.id = id;
      this.uri = uri;
      this.darkTheme = darkTheme;
      this.isCircular = isCircular;
      this.requestedExtent = requestedExtent;
      this.defaultProvider = 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 uri != null;
    }

    public Uri getUri() {
      return uri;
    }

    public long getId() {
      return id;
    }

    public int getRequestedExtent() {
      return requestedExtent;
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + (int) (id ^ (id >>> 32));
      result = prime * result + requestedExtent;
      result = prime * result + ((uri == null) ? 0 : uri.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 (id != that.id) {
        return false;
      }
      if (requestedExtent != that.requestedExtent) {
        return false;
      }
      if (!UriUtils.areEqual(uri, that.uri)) {
        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 uri == null ? id : uri;
    }

    /**
     * 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(uri)
                ? DefaultImageRequest.EMPTY_CIRCULAR_BUSINESS_IMAGE_REQUEST
                : DefaultImageRequest.EMPTY_CIRCULAR_DEFAULT_IMAGE_REQUEST;
      } else {
        request =
            ContactPhotoManager.isBusinessContactUri(uri)
                ? DefaultImageRequest.EMPTY_DEFAULT_BUSINESS_IMAGE_REQUEST
                : DefaultImageRequest.EMPTY_DEFAULT_IMAGE_REQUEST;
      }
      defaultProvider.applyDefaultImage(view, requestedExtent, darkTheme, 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 resolver;
    private final StringBuilder stringBuilder = new StringBuilder();
    private final Set<Long> photoIds = new HashSet<>();
    private final Set<String> photoIdsAsStrings = new HashSet<>();
    private final Set<Request> photoUris = new HashSet<>();
    private final List<Long> preloadPhotoIds = new ArrayList<>();
    private Handler loaderThreadHandler;
    private byte[] buffer;
    private int preloadStatus = PRELOAD_STATUS_NOT_STARTED;

    public LoaderThread(ContentResolver resolver) {
      super(LOADER_THREAD_NAME);
      this.resolver = resolver;
    }

    public void ensureHandler() {
      if (loaderThreadHandler == null) {
        loaderThreadHandler = 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 (preloadStatus == PRELOAD_STATUS_DONE) {
        return;
      }

      ensureHandler();
      if (loaderThreadHandler.hasMessages(MESSAGE_LOAD_PHOTOS)) {
        return;
      }

      loaderThreadHandler.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();
      loaderThreadHandler.removeMessages(MESSAGE_PRELOAD_PHOTOS);
      loaderThreadHandler.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(context, android.Manifest.permission.READ_CONTACTS)) {
        return;
      }

      if (preloadStatus == PRELOAD_STATUS_DONE) {
        return;
      }

      if (preloadStatus == PRELOAD_STATUS_NOT_STARTED) {
        queryPhotosForPreload();
        if (preloadPhotoIds.isEmpty()) {
          preloadStatus = PRELOAD_STATUS_DONE;
        } else {
          preloadStatus = PRELOAD_STATUS_IN_PROGRESS;
        }
        requestPreloading();
        return;
      }

      if (bitmapHolderCache.size() > bitmapHolderCacheRedZoneBytes) {
        preloadStatus = PRELOAD_STATUS_DONE;
        return;
      }

      photoIds.clear();
      photoIdsAsStrings.clear();

      int count = 0;
      int preloadSize = preloadPhotoIds.size();
      while (preloadSize > 0 && photoIds.size() < PRELOAD_BATCH) {
        preloadSize--;
        count++;
        Long photoId = preloadPhotoIds.get(preloadSize);
        photoIds.add(photoId);
        photoIdsAsStrings.add(photoId.toString());
        preloadPhotoIds.remove(preloadSize);
      }

      loadThumbnails(true);

      if (preloadSize == 0) {
        preloadStatus = PRELOAD_STATUS_DONE;
      }

      LogUtil.v(
          "ContactPhotoManagerImpl.preloadPhotosInBackground",
          "preloaded " + count + " photos.  cached bytes: " + bitmapHolderCache.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 =
            resolver.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.
            preloadPhotoIds.add(0, cursor.getLong(0));
          }
        }
      } finally {
        if (cursor != null) {
          cursor.close();
        }
      }
    }

    @WorkerThread
    private void loadPhotosInBackground() {
      if (!PermissionsUtil.hasPermission(context, android.Manifest.permission.READ_CONTACTS)) {
        return;
      }
      obtainPhotoIdsAndUrisToLoad(photoIds, photoIdsAsStrings, photoUris);
      loadThumbnails(false);
      loadUriBasedPhotos();
      requestPreloading();
    }

    /** Loads thumbnail photos with ids */
    @WorkerThread
    private void loadThumbnails(boolean preloading) {
      if (photoIds.isEmpty()) {
        return;
      }

      // Remove loaded photos from the preload queue: we don't want
      // the preloading process to load them again.
      if (!preloading && preloadStatus == PRELOAD_STATUS_IN_PROGRESS) {
        for (Long id : photoIds) {
          preloadPhotoIds.remove(id);
        }
        if (preloadPhotoIds.isEmpty()) {
          preloadStatus = PRELOAD_STATUS_DONE;
        }
      }

      stringBuilder.setLength(0);
      stringBuilder.append(Photo._ID + " IN(");
      for (int i = 0; i < photoIds.size(); i++) {
        if (i != 0) {
          stringBuilder.append(',');
        }
        stringBuilder.append('?');
      }
      stringBuilder.append(')');

      Cursor cursor = null;
      try {
        if (DEBUG) {
          LogUtil.d(
              "ContactPhotoManagerImpl.loadThumbnails",
              "loading " + TextUtils.join(",", photoIdsAsStrings));
        }
        cursor =
            resolver.query(
                Data.CONTENT_URI,
                COLUMNS,
                stringBuilder.toString(),
                photoIdsAsStrings.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);
            photoIds.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 : photoIds) {
        if (ContactsContract.isProfileId(id)) {
          Cursor profileCursor = null;
          try {
            profileCursor =
                resolver.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);
        }
      }

      mainThreadHandler.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 : photoUris) {
        // 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 (buffer == null) {
          buffer = 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(userAgent)) {
                connection.setRequestProperty("User-Agent", userAgent);
              }
              try {
                is = connection.getInputStream();
              } catch (IOException e) {
                connection.disconnect();
                is = null;
              }
            } finally {
              TrafficStats.clearThreadStatsTag();
            }
          } else {
            is = resolver.openInputStream(uri);
          }
          if (is != null) {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            try {
              int size;
              while ((size = is.read(buffer)) != -1) {
                baos.write(buffer, 0, size);
              }
            } finally {
              is.close();
            }
            cacheBitmap(originalUri, baos.toByteArray(), false, uriRequest.getRequestedExtent());
            mainThreadHandler.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());
        }
      }
    }
  }
}