上一篇使用XUtils的BitmapUtils实现了一个照片墙的功能，参见：android-----XUtils框架之BitmapUtils加载照片实现，这一篇我们从源码的角度分析下BitmapUtils到底是怎么一个执行流程的；
先来回顾下之前我们使用BitmapUtils的步骤：
很简单，就只有两步：
(1)通过BitmapUtils的构造函数创建对象；
(2)调用BitmapUtils对象的display方法；
好了，我们先从创建BitmapUtils对象开始分析，很自然想到了BitmapUtils的构造函数啦：
public BitmapUtils(Context context) {
this(context, null);
}
public BitmapUtils(Context context, String diskCachePath) {
if (context == null) {
throw new IllegalArgumentException("context may not be null");
}
this.context = context;
globalConfig = new BitmapGlobalConfig(context, diskCachePath);
defaultDisplayConfig = new BitmapDisplayConfig();
}
public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize) {
this(context, diskCachePath);
globalConfig.setMemoryCacheSize(memoryCacheSize);
}
public BitmapUtils(Context context, String diskCachePath, int memoryCacheSize, int diskCacheSize) {
this(context, diskCachePath);
globalConfig.setMemoryCacheSize(memoryCacheSize);
globalConfig.setDiskCacheSize(diskCacheSize);
}
public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent) {
this(context, diskCachePath);
globalConfig.setMemCacheSizePercent(memoryCachePercent);
}
public BitmapUtils(Context context, String diskCachePath, float memoryCachePercent, int diskCacheSize) {
this(context, diskCachePath);
globalConfig.setMemCacheSizePercent(memoryCachePercent);
globalConfig.setDiskCacheSize(diskCacheSize);
}
public BitmapGlobalConfig(Context context, String diskCachePath) {
if (context == null) throw new IllegalArgumentException("context may not be null");
this.mContext = context;
this.diskCachePath = diskCachePath;
initBitmapCache();
}
private void initBitmapCache() {
new BitmapCacheManagementTask().execute(BitmapCacheManagementTask.MESSAGE_INIT_MEMORY_CACHE);
new BitmapCacheManagementTask().execute(BitmapCacheManagementTask.MESSAGE_INIT_DISK_CACHE);
}
public final PriorityAsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final PriorityAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
return executeOnExecutor(exec, Priority.DEFAULT, params);
}
public final PriorityAsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Priority priority,
Params... params) {
if (mExecuteInvoked) {
throw new IllegalStateException("Cannot execute task:"
+ " the task is already executed.");
}
mExecuteInvoked = true;
onPreExecute();
mWorker.mParams = params;
exec.execute(new PriorityRunnable(priority, mFuture));
return this;
}
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//noinspection unchecked
return postResult(doInBackground(mParams));
}
};可以看到他确实实现了call方法
继续上面的executeOnExecutor方法讲解，第19行调用了线程池的execute将新创建的PriorityRunnable对象加入到了线程池，具体的执行调用的是创建PriorityRunnable的run方法啦，而PriorityRunnable的run方法其实调用的是第二个参数也就是这里mFuture的run方法，这点在源码中也体现出来了：
@Override
public void run() {
this.obj.run();
}
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (InterruptedException e) {
LogUtils.w(e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
public void initMemoryCache() {
if (!globalConfig.isMemoryCacheEnabled()) return;
// Set up memory cache
if (mMemoryCache != null) {
try {
clearMemoryCache();
} catch (Throwable e) {
}
}
mMemoryCache = new LruMemoryCache<MemoryCacheKey, Bitmap>(globalConfig.getMemoryCacheSize()) {
/**
* Measure item size in bytes rather than units which is more practical
* for a bitmap cache
*/
@Override
protected int sizeOf(MemoryCacheKey key, Bitmap bitmap) {
if (bitmap == null) return 0;
return bitmap.getRowBytes() * bitmap.getHeight();
}
};
} 这样initBitmapCache的第2行代码分析完毕，其实就是创建了一个内存缓存LruMemoryCache对象，第3行代码传入的参数是BitmapCacheManagementTask.MESSAGE_INIT_DISK_CACHE，在经历和上面一样的步骤之后会走到BitmapGlobalConfig内部类BitmapCacheManagementTask的doInBackground方法里面，执行他标志为MESSAGE_INIT_DISK_CACHE的case语句块：
case MESSAGE_INIT_DISK_CACHE:
cache.initDiskCache();
break;
public void initDiskCache() {
if (!globalConfig.isDiskCacheEnabled()) return;
// Set up disk cache
synchronized (mDiskCacheLock) {
if (mDiskLruCache == null || mDiskLruCache.isClosed()) {
File diskCacheDir = new File(globalConfig.getDiskCachePath());
if (diskCacheDir.exists() || diskCacheDir.mkdirs()) {
long availableSpace = OtherUtils.getAvailableSpace(diskCacheDir);
long diskCacheSize = globalConfig.getDiskCacheSize();
diskCacheSize = availableSpace > diskCacheSize ? diskCacheSize : availableSpace;
try {
mDiskLruCache = LruDiskCache.open(diskCacheDir, 1, 1, diskCacheSize);
mDiskLruCache.setFileNameGenerator(globalConfig.getFileNameGenerator());
} catch (Throwable e) {
mDiskLruCache = null;
LogUtils.e(e.getMessage(), e);
}
}
}
isDiskCacheReadied = true;
mDiskCacheLock.notifyAll();
}
}至此，调用完initBitmapCache方法之后就创建出来内存缓存以及SD卡缓存了，BitmapGlobalConfig构造函数也就执行结束，BitmapUtils包含两个参数的构造方法中也就创建了BitmapGlobalConfig对象了，接着在BitmapUtils包含两个参数的构造方法中我们看到穿件了BitmapDisplayConfig对象，这个对象主要用来设置显示图片的一些属性的，比如动画、旋转之类的，这个不是重点；
那么BitmapUtils最重要的两个参数构造函数源码就执行结束了，至于其他5个构造函数基本上都是自定义设置缓存大小的一些操作，都可以从参数名字上面体现出来，这里就不再赘述；
有了BitmapUtils对象，下一步我们就要调用display方法请求网络图片或者本地图片或者assets文件夹下面的图片显示到控件上面了，很显然display将是重要方法：
public <T extends View> void display(T container, String uri) {
display(container, uri, null, null);
}
public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig) {
display(container, uri, displayConfig, null);
}
public <T extends View> void display(T container, String uri, BitmapLoadCallBack<T> callBack) {
display(container, uri, null, callBack);
}
public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig, BitmapLoadCallBack<T> callBack) {
}可以看到display共有4个重载实现，但是他们最终都会聚集到第四个实现上面，所以我们只需要分析第四个即可，先来看看他的四个参数个表示什么：
container：表示所要显示图片的控件；
uri：表示请求图片的地址，注意这个可以是本地路径或者assets文件夹下面的路径；
displayConfig：对显示图片的一些操作，比如动画呀，旋转呀之类的；
callBack：图片加载的一些回调接口实现对象；
这里面我们需要看看BitmapLoadCallBack里面提供了哪些回调方法可以让我们在加载图片的过程中进行一些提示用户操作：
public abstract class BitmapLoadCallBack<T extends View> {
public void onPreLoad(T container, String uri, BitmapDisplayConfig config) {
}
public void onLoadStarted(T container, String uri, BitmapDisplayConfig config) {
}
public void onLoading(T container, String uri, BitmapDisplayConfig config, long total, long current) {
}
public abstract void onLoadCompleted(T container, String uri, Bitmap bitmap, BitmapDisplayConfig config, BitmapLoadFrom from);
public abstract void onLoadFailed(T container, String uri, Drawable drawable);
}好啦，开始进入display方法里面了：
public <T extends View> void display(T container, String uri, BitmapDisplayConfig displayConfig, BitmapLoadCallBack<T> callBack) {
if (container == null) {
return;
}
container.clearAnimation();
if (callBack == null) {
callBack = new DefaultBitmapLoadCallBack<T>();
}
if (displayConfig == null || displayConfig == defaultDisplayConfig) {
displayConfig = defaultDisplayConfig.cloneNew();
}
// Optimize Max Size
BitmapSize size = displayConfig.getBitmapMaxSize();
displayConfig.setBitmapMaxSize(BitmapCommonUtils.optimizeMaxSizeByView(container, size.getWidth(), size.getHeight()));
callBack.onPreLoad(container, uri, displayConfig);
if (TextUtils.isEmpty(uri)) {
callBack.onLoadFailed(container, uri, displayConfig.getLoadFailedDrawable());
return;
}
// find bitmap from mem cache.
Bitmap bitmap = globalConfig.getBitmapCache().getBitmapFromMemCache(uri, displayConfig);
if (bitmap != null) {
callBack.onLoadStarted(container, uri, displayConfig);
callBack.onLoadCompleted(
container,
uri,
bitmap,
displayConfig,
BitmapLoadFrom.MEMORY_CACHE);
} else if (!bitmapLoadTaskExist(container, uri, callBack)) {
final BitmapLoadTask<T> loadTask = new BitmapLoadTask<T>(container, uri, displayConfig, callBack);
// load bitmap from uri or diskCache
PriorityExecutor executor = globalConfig.getBitmapLoadExecutor();
File diskCacheFile = this.getBitmapFileFromDiskCache(uri);
boolean diskCacheExist = diskCacheFile != null && diskCacheFile.exists();
if (diskCacheExist && executor.isBusy()) {
executor = globalConfig.getDiskCacheExecutor();
}
// set loading image
Drawable loadingDrawable = displayConfig.getLoadingDrawable();
callBack.setDrawable(container, new AsyncDrawable<T>(loadingDrawable, loadTask));
Priority priority = displayConfig.getPriority();
if (priority == null) {
priority = Priority.DEFAULT;
}
loadTask.executeOnExecutor(executor, priority);
}
}
@Override
public void onLoadCompleted(T container, String uri, Bitmap bitmap, BitmapDisplayConfig config, BitmapLoadFrom from) {
this.setBitmap(container, bitmap);
Animation animation = config.getAnimation();
if (animation != null) {
animationDisplay(container, animation);
}
}
@Override
public void onLoadFailed(T container, String uri, Drawable drawable) {
this.setDrawable(container, drawable);
}
private void animationDisplay(T container, Animation animation) {
try {
Method cloneMethod = Animation.class.getDeclaredMethod("clone");
cloneMethod.setAccessible(true);
container.startAnimation((Animation) cloneMethod.invoke(animation));
} catch (Throwable e) {
container.startAnimation(animation);
}
}可以看到他实现了BitmapLoadCallBack抽象类的里面的onLoadCompleted和onLoadFailed方法，onLoadCompleted是在加载成功之后回调的方法，第3行调用setBitmap方法将图片显示到container上面，接着第4行查看是否设置了animation属性，如果设置了的话调用animationDisplay方法开启animation属性，这个方法会通过反射来克隆一个Animation对象出来，并且调用startAnimation方法来将动画设置到控件上面；onLoadFailed方法会在加载图片失败的时候调用，至于onLoadCompleted和onLoadFailed这两个方法的调用时机会在后面介绍；
回到display方法，接下来第12行如果display方法的第三个参数displayConfig为空或者等于defaultDisplayConfig的话，则调用cloneNew方法深度拷贝defaultDisplayConfig给displayConfig，第17行获取需要设置图片的大小，我们来看看getBitmapMaxSize方法：
public BitmapSize getBitmapMaxSize() {
return bitmapMaxSize == null ? BitmapSize.ZERO : bitmapMaxSize;
}回到display方法，第18行首先通过optimizeMaxSizeByView方法来根据View的大小以及bitmapsize的大小来计算出最终设置成图片的大小，随后调用setBitmapMaxSize方法将其设置到配置对象上面，来看看optimizeMaxSizeByView方法：
public static BitmapSize optimizeMaxSizeByView(View view, int maxImageWidth, int maxImageHeight) {
int width = maxImageWidth;
int height = maxImageHeight;
if (width > 0 && height > 0) {
return new BitmapSize(width, height);
}
final ViewGroup.LayoutParams params = view.getLayoutParams();
if (params != null) {
if (params.width > 0) {
width = params.width;
} else if (params.width != ViewGroup.LayoutParams.WRAP_CONTENT) {
width = view.getWidth();
}
if (params.height > 0) {
height = params.height;
} else if (params.height != ViewGroup.LayoutParams.WRAP_CONTENT) {
height = view.getHeight();
}
}
if (width <= 0) width = getImageViewFieldValue(view, "mMaxWidth");
if (height <= 0) height = getImageViewFieldValue(view, "mMaxHeight");
BitmapSize screenSize = getScreenSize(view.getContext());
if (width <= 0) width = screenSize.getWidth();
if (height <= 0) height = screenSize.getHeight();
return new BitmapSize(width, height);
}回到display方法里面，接着第20行调用callBack的onPreLoad方法，这个方法是我们自己实现的，具体实现在我们调用display方法的第四个参数里面，22行判断如果请求地址为空的话，直接调用callBack的onLoadFailed方法显示出错信息，并且直接return；接着第28行通过getBitmapFromMemCache方法从内存缓存中读取对应uri的Bitmap：
public Bitmap getBitmapFromMemCache(String uri, BitmapDisplayConfig config) {
if (mMemoryCache != null && globalConfig.isMemoryCacheEnabled()) {
MemoryCacheKey key = new MemoryCacheKey(uri, config);
return mMemoryCache.get(key);
}
return null;
}回到display方法，如果bitmap不为空的话，表示内存缓存中存在对应于uri的Bitmap对象，那么我们调用callback的onLoadStarted提示开始加载图片已经结束，以及onLoadCompleted图片已经把加载完成并且把Bitmap显示在控件上面；如果bitmap为空，表示当前内存缓存中并不存在对应于uri的bitmap，那么首先会在38行通过bitmapLoadTaskExist来判断是否已经存在加载当前uri图片的任务，我们来看看bitmapLoadTaskExist方法：
private static <T extends View> boolean bitmapLoadTaskExist(T container, String uri, BitmapLoadCallBack<T> callBack) {
final BitmapLoadTask<T> oldLoadTask = getBitmapTaskFromContainer(container, callBack);
if (oldLoadTask != null) {
final String oldUrl = oldLoadTask.uri;
if (TextUtils.isEmpty(oldUrl) || !oldUrl.equals(uri)) {
oldLoadTask.cancel(true);
} else {
return true;
}
}
return false;
}回到display方法，可以看到只有当bitmapLoadTaskExist返回false的情况下才会进入if语句块的，这样子保证了不存在有两个异步任务加载同一个uri上面图片的情况，接下来的40行到56行分别创建了一个指定container, uri, displayConfig, callBack的BitmapLoadTask对象，创建了一个PriorityExecutor类型的线程池对象，设置了正在加载图片的过程中控件上所显示的图片，以及当前异步任务的优先级，最后57行执行了BitmapLoadTask的executeOnExecutor，熟悉AsyncTask源码的应该都知道执行executeOnExecutor方法最终会进入到BitmapLoadTask的doInBackground方法里面，注意BitmapLoadTask是BitmapUtils的内部类，我们来看看这里面的代码：
@Override
protected Bitmap doInBackground(Object... params) {
synchronized (pauseTaskLock) {
while (pauseTask && !this.isCancelled()) {
try {
pauseTaskLock.wait();
if (cancelAllTask) {
return null;
}
} catch (Throwable e) {
}
}
}
Bitmap bitmap = null;
// get cache from disk cache
if (!this.isCancelled() && this.getTargetContainer() != null) {
this.publishProgress(PROGRESS_LOAD_STARTED);
bitmap = globalConfig.getBitmapCache().getBitmapFromDiskCache(uri, displayConfig);
}
// download image
if (bitmap == null && !this.isCancelled() && this.getTargetContainer() != null) {
bitmap = globalConfig.getBitmapCache().downloadBitmap(uri, displayConfig, this);
from = BitmapLoadFrom.URI;
}
return bitmap;
}
case PROGRESS_LOAD_STARTED:
callBack.onLoadStarted(container, uri, displayConfig);
break;接着第21行调用getBitmapFromDiskCache方法从SD卡缓存中获取Bitmap对象，我们来看看这个方法：
public Bitmap getBitmapFromDiskCache(String uri, BitmapDisplayConfig config) {
if (uri == null || !globalConfig.isDiskCacheEnabled()) return null;
synchronized (mDiskCacheLock) {
while (!isDiskCacheReadied) {
try {
mDiskCacheLock.wait();
} catch (Throwable e) {
}
}
if (mDiskLruCache != null) {
LruDiskCache.Snapshot snapshot = null;
try {
snapshot = mDiskLruCache.get(uri);
if (snapshot != null) {
Bitmap bitmap = null;
if (config == null || config.isShowOriginal()) {
bitmap = BitmapDecoder.decodeFileDescriptor(
snapshot.getInputStream(DISK_CACHE_INDEX).getFD());
} else {
bitmap = BitmapDecoder.decodeSampledBitmapFromDescriptor(
snapshot.getInputStream(DISK_CACHE_INDEX).getFD(),
config.getBitmapMaxSize(),
config.getBitmapConfig());
}
bitmap = rotateBitmapIfNeeded(uri, config, bitmap);
addBitmapToMemoryCache(uri, config, bitmap, mDiskLruCache.getExpiryTimestamp(uri));
return bitmap;
}
} catch (Throwable e) {
LogUtils.e(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(snapshot);
}
}
return null;
}
}
private void addBitmapToMemoryCache(String uri, BitmapDisplayConfig config, Bitmap bitmap, long expiryTimestamp) throws IOException {
if (uri != null && bitmap != null && globalConfig.isMemoryCacheEnabled() && mMemoryCache != null) {
MemoryCacheKey key = new MemoryCacheKey(uri, config);
mMemoryCache.put(key, bitmap, expiryTimestamp);
}
}上面对于SD卡缓存讲的不怎么详细，因为之前的博客已经分析过这方面的源码了包括图片压缩技术，有兴趣的可以看看：android-----带你一步一步优化ListView(二)以及android-----解决Bitmap内存溢出的一种方法(图片压缩技术)，
回到我们的doInBackground方法，第25行判断从SD卡缓存中获取的Bitmap是否为空，以及当前异步任务是否暂停、显示图片的控件是否存在，如果满足if条件的话，表示SD卡缓存上面也不存在当前uri对应的bitmap，那么我们只能从网络中获取了，也就是这里的downloadBitmap方法了：
public Bitmap downloadBitmap(String uri, BitmapDisplayConfig config, final BitmapUtils.BitmapLoadTask<?> task) {
BitmapMeta bitmapMeta = new BitmapMeta();
OutputStream outputStream = null;
LruDiskCache.Snapshot snapshot = null;
try {
Bitmap bitmap = null;
// try download to disk
if (globalConfig.isDiskCacheEnabled()) {
synchronized (mDiskCacheLock) {
// Wait for disk cache to initialize
while (!isDiskCacheReadied) {
try {
mDiskCacheLock.wait();
} catch (Throwable e) {
}
}
if (mDiskLruCache != null) {
try {
snapshot = mDiskLruCache.get(uri);
if (snapshot == null) {
LruDiskCache.Editor editor = mDiskLruCache.edit(uri);
if (editor != null) {
outputStream = editor.newOutputStream(DISK_CACHE_INDEX);
bitmapMeta.expiryTimestamp = globalConfig.getDownloader().downloadToStream(uri, outputStream, task);
if (bitmapMeta.expiryTimestamp < 0) {
editor.abort();
return null;
} else {
editor.setEntryExpiryTimestamp(bitmapMeta.expiryTimestamp);
editor.commit();
}
snapshot = mDiskLruCache.get(uri);
}
}
if (snapshot != null) {
bitmapMeta.inputStream = snapshot.getInputStream(DISK_CACHE_INDEX);
bitmap = decodeBitmapMeta(bitmapMeta, config);
if (bitmap == null) {
bitmapMeta.inputStream = null;
mDiskLruCache.remove(uri);
}
}
} catch (Throwable e) {
LogUtils.e(e.getMessage(), e);
}
}
}
}
// try download to memory stream
if (bitmap == null) {
outputStream = new ByteArrayOutputStream();
bitmapMeta.expiryTimestamp = globalConfig.getDownloader().downloadToStream(uri, outputStream, task);
if (bitmapMeta.expiryTimestamp < 0) {
return null;
} else {
bitmapMeta.data = ((ByteArrayOutputStream) outputStream).toByteArray();
bitmap = decodeBitmapMeta(bitmapMeta, config);
}
}
if (bitmap != null) {
bitmap = rotateBitmapIfNeeded(uri, config, bitmap);
if (config != null && config.getImageFactory() != null) {
bitmap = config.getImageFactory().createBitmap(bitmap);
}
addBitmapToMemoryCache(uri, config, bitmap, bitmapMeta.expiryTimestamp);
}
return bitmap;
} catch (Throwable e) {
LogUtils.e(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(outputStream);
IOUtils.closeQuietly(snapshot);
}
return null;
}
@Override
public long downloadToStream(String uri, OutputStream outputStream, final BitmapUtils.BitmapLoadTask<?> task) {
if (task == null || task.isCancelled() || task.getTargetContainer() == null) return -1;
URLConnection urlConnection = null;
BufferedInputStream bis = null;
OtherUtils.trustAllSSLForHttpsURLConnection();
long result = -1;
long fileLen = 0;
long currCount = 0;
try {
if (uri.startsWith("/")) {
FileInputStream fileInputStream = new FileInputStream(uri);
fileLen = fileInputStream.available();
bis = new BufferedInputStream(fileInputStream);
result = System.currentTimeMillis() + this.getDefaultExpiry();
} else if (uri.startsWith("assets/")) {
InputStream inputStream = this.getContext().getAssets().open(uri.substring(7, uri.length()));
fileLen = inputStream.available();
bis = new BufferedInputStream(inputStream);
result = Long.MAX_VALUE;
} else {
final URL url = new URL(uri);
urlConnection = url.openConnection();
urlConnection.setConnectTimeout(this.getDefaultConnectTimeout());
urlConnection.setReadTimeout(this.getDefaultReadTimeout());
bis = new BufferedInputStream(urlConnection.getInputStream());
result = urlConnection.getExpiration();
result = result < System.currentTimeMillis() ? System.currentTimeMillis() + this.getDefaultExpiry() : result;
fileLen = urlConnection.getContentLength();
}
if (task.isCancelled() || task.getTargetContainer() == null) return -1;
byte[] buffer = new byte[4096];
int len = 0;
while ((len = bis.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
currCount += len;
if (task.isCancelled() || task.getTargetContainer() == null) return -1;
task.updateProgress(fileLen, currCount);
}
outputStream.flush();
} catch (Throwable e) {
result = -1;
LogUtils.e(e.getMessage(), e);
} finally {
IOUtils.closeQuietly(bis);
}
return result;
}
public void updateProgress(long total, long current) {
this.publishProgress(PROGRESS_LOADING, total, current);
}
case PROGRESS_LOADING:
if (values.length != 3) return;
callBack.onLoading(container, uri, displayConfig, (Long) values[1], (Long) values[2]);
break;回到downloadBitmap方法中，第56行判断如果bitmap为空的话，则需要进入if语句块中，那么什么情况下会出现bitmap为空呢？SD卡不存在或者不可用的情况下，进入if语句块之后同样也会在第58行执行downloadToStream方法区网络中获取图片，接着在第67行判断上面获得的bitmap是否为空，如果非空的话会在第72行将其添加到内存缓存中，addBitmapToMemoryCache方法前面已经介绍过了，不再赘述，那么downloadBitmap方法大致分析结束了；
downloadBitmap结束之后doInBackground方法也就执行结束啦，最后返回我们获取到的bitmap对象；
到现在，我们获取到了bitmap对象对象，但是如果我们是通过异步任务获取的bitmap对象的话，我们将其设置到控件上面是什么时候呢？
在BitmapUtils里面我们找到了onPostExecute方法，这个方法就是就是我们在doInBackground执行结束之后会回调的方法啦，AsyncTask源码中已经分析过了：
@Override
protected void onPostExecute(Bitmap bitmap) {
final T container = this.getTargetContainer();
if (container != null) {
if (bitmap != null) {
callBack.onLoadCompleted(
container,
this.uri,
bitmap,
displayConfig,
from);
} else {
callBack.onLoadFailed(
container,
this.uri,
displayConfig.getLoadFailedDrawable());
}
}
}
至此，BitmapUtils源码答题分析结束了，希望有错的地方大家可以纠正，赠人玫瑰，手留余香！！！！！
扫一扫
2021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
