UniversalImageLoader源码解读02-图片处理和显示

好了，有了ImageAware，我们知道是谁包装了我们的ImageView， 图片在哪里显示，现在我们把目光转向Bitmap的处理。

BitmapProcessor， 这个接口非常简单，只有一个方法Bitmap process(Bitmap bitmap); 可惜的是，框架并没有给我们提供默认实现，我们需要自己实现。

比如我们想在图片的右下角加个水印，或者将图片变成灰度图，或者做个高斯模糊，都可以实现这个接口，然后在DisplayImageOptions中使用。

BitmapDisplayer , 这个接口也非常简单， 也只有一个方法 void display(Bitmap bitmap, ImageAware imageAware, LoadedFrom loadedFrom); 值得高兴的是，框架为我们提供了好几个默认实现，这里我只讲最简单的一个SimpleBitmapDisplayer，也是最常用的，功能很简单，只是单纯的 设置了一下图片而已

public final class SimpleBitmapDisplayer implements BitmapDisplayer {
@Override
public void display(Bitmap bitmap, ImageAware imageAware, LoadedFrom loadedFrom) {
imageAware.setImageBitmap(bitmap);//把图片设置到ImageAware包装的ImageView上
}
}

LoadedFrom 这个类封装了图片的来源，是个枚举

public enum LoadedFrom {
NETWORK, DISC_CACHE, MEMORY_CACHE // 网络，磁盘缓存，内存缓存
}

ImageDecoder这个接口也非常简单， 也只有一个方法 Bitmap decode(ImageDecodingInfo imageDecodingInfo) throws IOException; 并且为我们提供了一个默认实现

BaseImageDecoder ， 这里比较重要的是ImageDecodingInfo，里面包含一些和图片缓存，下载等相关的信息，这里介绍几个重要属性，其他的自己看

private final String imageKey;//图片的唯一标识，全局唯一，作为内存缓存的key
private final String imageUri;//图片的Uri，可能是http:// file://等
private final ImageDownloader downloader;// 图片加载器，后面会详细介绍，这里你只要知道这个类的职责是从图片源(磁盘，网络) 去下载图片即可

ImageDownloader 接口非常简单，只有一个方法 InputStream getStream(String imageUri, Object extra) throws IOException; 和一个Scheme，Scheme的作用是定义图片的加载Uri，这里有必要说一下，以免有些人不知道如何使用ImageLoader去加载资源文件夹中的图片，请看定义

public enum Scheme {
HTTP("http"), HTTPS("https"), FILE("file"), CONTENT("content"), ASSETS("assets"), DRAWABLE("drawable"), UNKNOWN("");

private String scheme;
private String uriPrefix;

Scheme(String scheme) {
this.scheme = scheme;
uriPrefix = scheme + "://";
}

public static Scheme ofUri(String uri) {
if (uri != null) {
for (Scheme s : values()) {
if (s.belongsTo(uri)) {
return s;
}
}
}
return UNKNOWN;
}

private boolean belongsTo(String uri) {
return uri.toLowerCase(Locale.US).startsWith(uriPrefix);
}

/** Appends scheme to incoming path */
public String wrap(String path) {
return uriPrefix + path;
}

/** Removed scheme part ("scheme://") from incoming URI */
public String crop(String uri) {
if (!belongsTo(uri)) {
throw new IllegalArgumentException(String.format("URI [%1$s] doesn't have expected scheme [%2$s]", uri, scheme));
}
return uri.substring(uriPrefix.length());
}
}

例子：加载网络图片Uri：http://www.xxxxxx.com/abc.jpg 或 https://www.xxxxxx.com/abc.jpg
加载sdcard图片Uri ： file:///sdcard/abc/def/aaaaa.jpg 注意file:// 后有一个根文件夹的盘符 ' / '，连一起是///

加载drawable文件夹下载资源文件 drawable://333125 注意一下这个数字是什么呢？是资源id ，也是R.drawable.icon 的值，使用时候你可以拼串

content asset下的资源同理，这里主要强调drawable,很多人不知道怎么用

接下来的内容非常重要，图片能否读取到，完全依赖于BaseImageDecoder， 这是一个重量级的类，占有举足轻重的地位

当然内容有很多，但是我们主要关注Bitmap decode(ImageDecodingInfo imageDecodingInfo) throws IOException; 这个方法，因为这个是接口定义的，子类必须实现的方法

@Override
public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException {
Bitmap decodedBitmap;
ImageFileInfo imageInfo;

InputStream imageStream = getImageStream(decodingInfo);//从ImageDownLoader中获取一个输入流
if (imageStream == null) {
L.e(ERROR_NO_IMAGE_STREAM, decodingInfo.getImageKey());
return null;
}
try {
imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo);
imageStream = resetStream(imageStream, decodingInfo);
Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo);
decodedBitmap = BitmapFactory.decodeStream(imageStream, null, decodingOptions);//从流中解出bitmap
} finally {
IoUtils.closeSilently(imageStream);
}

if (decodedBitmap == null) {
L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey());
} else {
decodedBitmap = considerExactScaleAndOrientatiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation,
imageInfo.exif.flipHorizontal);
}
return decodedBitmap;//把从流中解出的bitmap返回
}

其他的细节自己看吧，很简单，注释就是代码的主干逻辑，一阵折腾，就是为了从流中拿到bitmap

这里我有必要详细介绍一下BaseImageDownloader ，因为这个类作为开发者会经常用到，比如，存在服务器的图片并不是一个图片的二进制流，而是一个base64串，这个时候你必须实现自己的ImageDownLoader，这个BaseImageDownloader就是框架给我们提供的最好的例子，我们可以参考它来写我们自己的加载逻辑

public class BaseImageDownloader implements ImageDownloader {
/** {@value} */
public static final int DEFAULT_HTTP_CONNECT_TIMEOUT = 5 * 1000; // milliseconds
/** {@value} */
public static final int DEFAULT_HTTP_READ_TIMEOUT = 20 * 1000; // milliseconds

/** {@value} */
protected static final int BUFFER_SIZE = 32 * 1024; // 32 Kb
/** {@value} */
protected static final String ALLOWED_URI_CHARS = "@#&=*+-_.,:!?()/~'%";

protected static final int MAX_REDIRECT_COUNT = 5;

protected static final String CONTENT_CONTACTS_URI_PREFIX = "content://com.android.contacts/";

private static final String ERROR_UNSUPPORTED_SCHEME = "UIL doesn't support scheme(protocol) by default [%s]. " + "You should implement this support yourself (BaseImageDownloader.getStreamFromOtherSource(...))";

protected final Context context;
protected final int connectTimeout;
protected final int readTimeout;

public BaseImageDownloader(Context context) {
this.context = context.getApplicationContext();
this.connectTimeout = DEFAULT_HTTP_CONNECT_TIMEOUT;
this.readTimeout = DEFAULT_HTTP_READ_TIMEOUT;
}

public BaseImageDownloader(Context context, int connectTimeout, int readTimeout) {
this.context = context.getApplicationContext();
this.connectTimeout = connectTimeout;
this.readTimeout = readTimeout;
}

/**
* 这个是主干方法，就是根据传入的imageUri来判断应该去哪里加载图片
*/
@Override
public InputStream getStream(String imageUri, Object extra) throws IOException {
switch (Scheme.ofUri(imageUri)) {
case HTTP:
case HTTPS:
return getStreamFromNetwork(imageUri, extra);//从网络获取图片输入流，注释见下
case FILE:
return getStreamFromFile(imageUri, extra);
case CONTENT:
return getStreamFromContent(imageUri, extra);
case ASSETS:
return getStreamFromAssets(imageUri, extra);
case DRAWABLE:
return getStreamFromDrawable(imageUri, extra);//从资源drawable文件夹获取图片输入流，注释见下
case UNKNOWN:
default:
return getStreamFromOtherSource(imageUri, extra);
}
}

protected InputStream getStreamFromNetwork(String imageUri, Object extra) throws IOException {
HttpURLConnection conn = createConnection(imageUri, extra);

//创建http连接
int redirectCount = 0;
while (conn.getResponseCode() / 100 == 3 && redirectCount < MAX_REDIRECT_COUNT) {
conn = createConnection(conn.getHeaderField("Location"), extra);
redirectCount++;
}

//拿到输入流
InputStream imageStream;
try {
imageStream = conn.getInputStream();
} catch (IOException e) {
// Read all data to allow reuse connection (http://bit.ly/1ad35PY)
IoUtils.readAndCloseStream(conn.getErrorStream());
throw e;
}
//返回输入流
return new ContentLengthInputStream(new BufferedInputStream(imageStream, BUFFER_SIZE), conn.getContentLength());
}

protected HttpURLConnection createConnection(String url, Object extra) throws IOException {
String encodedUrl = Uri.encode(url, ALLOWED_URI_CHARS);
HttpURLConnection conn = (HttpURLConnection) new URL(encodedUrl).openConnection();
conn.setConnectTimeout(connectTimeout);
conn.setReadTimeout(readTimeout);
return conn;
}

protected InputStream getStreamFromFile(String imageUri, Object extra) throws IOException {
String filePath = Scheme.FILE.crop(imageUri);
return new ContentLengthInputStream(new BufferedInputStream(new FileInputStream(filePath), BUFFER_SIZE),
(int) new File(filePath).length());
}

protected InputStream getStreamFromContent(String imageUri, Object extra) throws FileNotFoundException {
ContentResolver res = context.getContentResolver();

Uri uri = Uri.parse(imageUri);
if (isVideoUri(uri)) { // video thumbnail
Long origId = Long.valueOf(uri.getLastPathSegment());
Bitmap bitmap = MediaStore.Video.Thumbnails
.getThumbnail(res, origId, MediaStore.Images.Thumbnails.MINI_KIND, null);
if (bitmap != null) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.PNG, 0, bos);
return new ByteArrayInputStream(bos.toByteArray());
}
} else if (imageUri.startsWith(CONTENT_CONTACTS_URI_PREFIX)) { // contacts photo
return ContactsContract.Contacts.openContactPhotoInputStream(res, uri);
}

return res.openInputStream(uri);
}

protected InputStream getStreamFromAssets(String imageUri, Object extra) throws IOException {
String filePath = Scheme.ASSETS.crop(imageUri);
return context.getAssets().open(filePath);
}

/**
* 我想，当你看到这里的时候，你会明白我为什么会说加载drawable要用drawable://787978了
*/
protected InputStream getStreamFromDrawable(String imageUri, Object extra) {
String drawableIdString = Scheme.DRAWABLE.crop(imageUri);
int drawableId = Integer.parseInt(drawableIdString);//parseInt()拿到资源id
return context.getResources().openRawResource(drawableId);//拿到输入流
}

protected InputStream getStreamFromOtherSource(String imageUri, Object extra) throws IOException {
throw new UnsupportedOperationException(String.format(ERROR_UNSUPPORTED_SCHEME, imageUri));
}

private boolean isVideoUri(Uri uri) {
String mimeType = context.getContentResolver().getType(uri);

if (mimeType == null) {
return false;
}

return mimeType.startsWith("video/");
}
}

看到这里，怎么把base64转成输入流，我想不用我继续往下说了