Java tutorial
/* * Copyright (C) 2010 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.DGSD.Teexter.Utils; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.lang.ref.Reference; import java.lang.ref.SoftReference; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import android.content.ComponentCallbacks2; import android.content.ContentResolver; import android.content.ContentUris; import android.content.Context; import android.content.res.Configuration; import android.database.Cursor; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable; 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.v4.util.LruCache; import android.util.Log; import android.widget.ImageView; import com.DGSD.Teexter.BuildConfig; import com.DGSD.Teexter.R; /** * Asynchronously loads contact photos and maintains a cache of photos. */ public abstract class ContactPhotoManager implements ComponentCallbacks2 { static final String TAG = "ContactPhotoManager"; public static final String CONTACT_PHOTO_SERVICE = "contactPhotos"; public static int getDefaultAvatarResId() { return R.drawable.ic_contact_picture; } public static abstract class DefaultImageProvider { public abstract void applyDefaultImage(ImageView view); } private static class AvatarDefaultImageProvider extends DefaultImageProvider { @Override public void applyDefaultImage(ImageView view) { view.setImageResource(getDefaultAvatarResId()); } } private static class BlankDefaultImageProvider extends DefaultImageProvider { private static Drawable sDrawable; @Override public void applyDefaultImage(ImageView view) { if (sDrawable == null) { Context context = view.getContext(); sDrawable = new ColorDrawable(context.getResources().getColor(R.color.image_placeholder)); } view.setImageDrawable(sDrawable); } } public static final DefaultImageProvider DEFAULT_AVATER = new AvatarDefaultImageProvider(); public static final DefaultImageProvider DEFAULT_BLANK = new BlankDefaultImageProvider(); /** * Requests the singleton instance of {@link AccountTypeManager} 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); if (BuildConfig.DEBUG) { Log.e(TAG, "No contact photo service in context: " + applicationContext); } } else { if (BuildConfig.DEBUG) { Log.v(TAG, "Got ContactPhotoManager"); } } return service; } public static synchronized ContactPhotoManager createContactPhotoManager(Context context) { return new ContactPhotoManagerImpl(context); } /** * Load photo into the supplied image view. If the photo is already cached, * it is displayed immediately. Otherwise a request is sent to load the * photo from the database. */ public abstract void loadPhoto(ImageView view, long photoId, DefaultImageProvider defaultProvider); /** * Calls * {@link #loadPhoto(ImageView, long, boolean, boolean, DefaultImageProvider)} * with {@link #DEFAULT_AVATER}. */ public final void loadPhoto(ImageView view, long photoId) { loadPhoto(view, photoId, DEFAULT_AVATER); } /** * Load photo into the supplied image view. If the photo is already cached, * it is displayed immediately. Otherwise a request is sent to load the * photo from the location specified by the URI. */ public abstract void loadPhoto(ImageView view, Uri photoUri, DefaultImageProvider defaultProvider); /** * Calls * {@link #loadPhoto(ImageView, Uri, boolean, boolean, DefaultImageProvider)} * with {@link #DEFAULT_AVATER}. */ public final void loadPhoto(ImageView view, Uri photoUri) { loadPhoto(view, photoUri, DEFAULT_AVATER); } /** * Remove photo from the supplied image view. This also cancels current * pending load request inside this photo manager. */ public abstract void removePhoto(ImageView view); /** * Temporarily stops loading photos from the database. */ public abstract void pause(); /** * Resumes loading photos from the database. */ public abstract void resume(); /** * Marks all cached photos for reloading. We can continue using cache but * should also make sure the photos haven't changed in the background and * notify the views if so. */ public abstract void refreshCache(); /** * Initiates a background process that over time will fill up cache with * preload photos. */ public abstract void preloadPhotosInBackground(); // ComponentCallbacks2 @Override public void onConfigurationChanged(Configuration newConfig) { } // ComponentCallbacks2 @Override public void onLowMemory() { } // ComponentCallbacks2 @Override public void onTrimMemory(int level) { } } class ContactPhotoManagerImpl extends ContactPhotoManager implements Callback { private static final String LOADER_THREAD_NAME = "ContactPhotoLoader"; /** * 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 }; /** * Maintains the state of a particular photo. */ private static class BitmapHolder { final byte[] bytes; volatile boolean fresh; Bitmap bitmap; Reference<Bitmap> bitmapRef; public BitmapHolder(byte[] bytes) { this.bytes = bytes; this.fresh = true; } } 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); /** * 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; /** 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 public ContactPhotoManagerImpl(Context context) { mContext = context; final float cacheSizeAdjustment = 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) { } }; 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) { } }; mBitmapHolderCacheRedZoneBytes = (int) (holderCacheSize * 0.75); } @Override public void onTrimMemory(int 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 loadPhoto(ImageView view, long photoId, DefaultImageProvider defaultProvider) { if (photoId == 0) { // No photo is needed defaultProvider.applyDefaultImage(view); mPendingRequests.remove(view); } else { loadPhotoByIdOrUri(view, Request.createFromId(photoId, defaultProvider)); } } @Override public void loadPhoto(ImageView view, Uri photoUri, DefaultImageProvider defaultProvider) { if (photoUri == null) { // No photo is needed defaultProvider.applyDefaultImage(view); mPendingRequests.remove(view); } else { loadPhotoByIdOrUri(view, Request.createFromUri(photoUri, defaultProvider)); } } private void loadPhotoByIdOrUri(ImageView view, Request request) { boolean loaded = loadCachedPhoto(view, request); 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); } @Override public void refreshCache() { for (BitmapHolder holder : mBitmapHolderCache.snapshot().values()) { 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. */ private boolean loadCachedPhoto(ImageView view, Request request) { BitmapHolder holder = mBitmapHolderCache.get(request.getKey()); if (holder == null) { // The bitmap has not been loaded - should display the placeholder // image. request.applyDefaultImage(view); return false; } if (holder.bytes == null) { request.applyDefaultImage(view); return holder.fresh; } // Optionally decode bytes into a bitmap inflateBitmap(holder); view.setImageBitmap(holder.bitmap); if (holder.bitmap != null) { // Put the bitmap in the LRU cache mBitmapCache.put(request, holder.bitmap); } // Soften the reference holder.bitmap = null; return holder.fresh; } /** * 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) { byte[] bytes = holder.bytes; if (bytes == null || bytes.length == 0) { return; } // 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 = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, null); holder.bitmap = bitmap; holder.bitmapRef = new SoftReference<Bitmap>(bitmap); } catch (OutOfMemoryError e) { // Do nothing - the photo will appear to be missing } } public void clear() { mPendingRequests.clear(); mBitmapHolderCache.evictAll(); mBitmapCache.evictAll(); } @Override public void pause() { mPaused = true; } @Override public void resume() { mPaused = false; 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(); } return true; } } 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() { Iterator<ImageView> iterator = mPendingRequests.keySet().iterator(); while (iterator.hasNext()) { ImageView view = iterator.next(); Request key = mPendingRequests.get(view); boolean loaded = loadCachedPhoto(view, key); 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) { BitmapHolder holder = new BitmapHolder(bytes); holder.fresh = true; // Unless this image is being preloaded, decode it right away while // we are still on the background thread. if (!preloading) { inflateBitmap(holder); } mBitmapHolderCache.put(key, holder); } /** * Populates an array of photo IDs that need to be loaded. */ private void obtainPhotoIdsAndUrisToLoad(Set<Long> photoIds, Set<String> photoIdsAsStrings, Set<Uri> uris) { photoIds.clear(); photoIdsAsStrings.clear(); uris.clear(); /* * 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(); BitmapHolder holder = mBitmapHolderCache.get(request); if (holder == null || !holder.fresh) { if (request.isUriRequest()) { uris.add(request.mUri); } else { photoIds.add(request.mId); photoIdsAsStrings.add(String.valueOf(request.mId)); } } } } /** * 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 final ContentResolver mResolver; private final StringBuilder mStringBuilder = new StringBuilder(); private final Set<Long> mPhotoIds = new HashSet<Long>(); private final Set<String> mPhotoIdsAsStrings = new HashSet<String>(); private final Set<Uri> mPhotoUris = new HashSet<Uri>(); private final List<Long> mPreloadPhotoIds = new ArrayList<Long>(); private Handler mLoaderThreadHandler; private byte mBuffer[]; 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 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. */ private void preloadPhotosInBackground() { 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 preloadSize = mPreloadPhotoIds.size(); while (preloadSize > 0 && mPhotoIds.size() < PRELOAD_BATCH) { preloadSize--; Long photoId = mPreloadPhotoIds.get(preloadSize); mPhotoIds.add(photoId); mPhotoIdsAsStrings.add(photoId.toString()); mPreloadPhotoIds.remove(preloadSize); } loadPhotosFromDatabase(true); if (preloadSize == 0) { mPreloadStatus = PRELOAD_STATUS_DONE; } requestPreloading(); } 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(); } } } private void loadPhotosInBackground() { obtainPhotoIdsAndUrisToLoad(mPhotoIds, mPhotoIdsAsStrings, mPhotoUris); loadPhotosFromDatabase(false); loadRemotePhotos(); requestPreloading(); } private void loadPhotosFromDatabase(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 { 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); 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); } else { // Couldn't load a photo this way either. cacheBitmap(id, null, preloading); } } finally { if (profileCursor != null) { profileCursor.close(); } } } else { // Not a profile photo and not found - mark the cache // accordingly cacheBitmap(id, null, preloading); } } mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED); } private void loadRemotePhotos() { for (Uri uri : mPhotoUris) { if (mBuffer == null) { mBuffer = new byte[BUFFER_SIZE]; } try { InputStream 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(uri, baos.toByteArray(), false); mMainThreadHandler.sendEmptyMessage(MESSAGE_PHOTOS_LOADED); } else { cacheBitmap(uri, null, false); } } catch (Exception ex) { cacheBitmap(uri, null, false); } } } } /** * 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 DefaultImageProvider mDefaultProvider; private Request(long id, Uri uri, DefaultImageProvider defaultProvider) { mId = id; mUri = uri; mDefaultProvider = defaultProvider; } public static Request createFromId(long id, DefaultImageProvider defaultProvider) { return new Request(id, null /* no URI */, defaultProvider); } public static Request createFromUri(Uri uri, DefaultImageProvider defaultProvider) { return new Request(0 /* no ID */, uri, defaultProvider); } public boolean isUriRequest() { return mUri != null; } @Override public int hashCode() { if (mUri != null) return mUri.hashCode(); // copied over from Long.hashCode() return (int) (mId ^ (mId >>> 32)); } @Override public boolean equals(Object o) { if (!(o instanceof Request)) return false; final Request that = (Request) o; // Don't compare equality of mHires and mDarkTheme fields because // these are only used // in the default contact photo case. When the contact does have a // photo, the contact // photo is the same regardless of mHires and mDarkTheme, so we // shouldn't need to put // the photo request on the queue twice. return mId == that.mId && (mUri == null ? that.mUri == null : mUri.equals(that.mUri)); } public Object getKey() { return mUri == null ? mId : mUri; } public void applyDefaultImage(ImageView view) { mDefaultProvider.applyDefaultImage(view); } } }