Glide原理(三)：图片解析处理、ImageView保证大小详解手机开发

Glide 怎么判断解析图片的

Glide 怎么保证ImageView宽高？

Glide 怎么判断图片旋转角度

以上三个问题是我自己在做一个图片池遇到的问题，趁机好好学习Glide

Glide解码的类在 Downsampler中，它的注释上写着：

Downsamples, decodes, and rotates images according to their exif orientation.

根据图像文件采样、解码、旋转图像

有几个重要的类：

• private final BitmapPool bitmapPool;

Bitmap池，是一个LruCache，内部保留着使用过的Bitmap，重复使用

• private final DisplayMetrics displayMetrics;

屏幕信息

• private final ArrayPool byteArrayPool;

同样是一个LruCache，最大是4MB，充当一个byte的buffer

• private final List parsers;

图像的头部信息解析器，例如图像类型、旋转角度等信息；

ImageHeaderParser有两个实现类：DefaultImageHeaderParser、 ExifInterfaceImageHeaderParser

DefaultImageHeaderParser是Glide自定义的默认的头部解析器

ExifInterfaceImageHeaderParser是支持SDK 27的基于 exifInterface的解析器

• private final HardwareConfigState hardwareConfigState = HardwareConfigState.getInstance();

目测跟硬件加速有关，具体还不清楚

计算图像大小、缩放、计算角度、解码、旋转

public Resource<Bitmap> decode(InputStream is, int requestedWidth, int requestedHeight, 
      Options options, DecodeCallbacks callbacks) throws IOException {
    
 
	// 以下具体是做一系列的BitmapFactory.Options的配置 
    byte[] bytesForOptions = byteArrayPool.get(ArrayPool.STANDARD_BUFFER_SIZE_BYTES, byte[].class); 
    BitmapFactory.Options bitmapFactoryOptions = getDefaultOptions(); // 获取Option 
    bitmapFactoryOptions.inTempStorage = bytesForOptions; // 设定一个可重复使用的临时存储空间 
 
    DecodeFormat decodeFormat = options.get(DECODE_FORMAT); 
    DownsampleStrategy downsampleStrategy = options.get(DownsampleStrategy.OPTION); 
    boolean fixBitmapToRequestedDimensions = options.get(FIX_BITMAP_SIZE_TO_REQUESTED_DIMENSIONS);  
    boolean isHardwareConfigAllowed = 
      options.get(ALLOW_HARDWARE_CONFIG) != null && options.get(ALLOW_HARDWARE_CONFIG); // 是否允许硬件加速 
 
    try {
    
	  // 进行解码流程 
      Bitmap result = decodeFromWrappedStreams(is, bitmapFactoryOptions, 
          downsampleStrategy, decodeFormat, isHardwareConfigAllowed, requestedWidth, 
          requestedHeight, fixBitmapToRequestedDimensions, callbacks); 
      return BitmapResource.obtain(result, bitmapPool); 
    } finally {
    
      releaseOptions(bitmapFactoryOptions); 
      byteArrayPool.put(bytesForOptions); 
    } 
  } 
   
  // 真正解码的流程 
  private Bitmap decodeFromWrappedStreams(InputStream is, 
      BitmapFactory.Options options, DownsampleStrategy downsampleStrategy, 
      DecodeFormat decodeFormat, boolean isHardwareConfigAllowed, int requestedWidth, 
      int requestedHeight, boolean fixBitmapToRequestedDimensions, 
      DecodeCallbacks callbacks) throws IOException {
    
     
	//1. 计算图像大小 
    int[] sourceDimensions = getDimensions(is, options, callbacks, bitmapPool); 
    int sourceWidth = sourceDimensions[0]; 
    int sourceHeight = sourceDimensions[1]; 
    String sourceMimeType = options.outMimeType; 
 
    if (sourceWidth == -1 || sourceHeight == -1) {
    
      isHardwareConfigAllowed = false; 
    } 
     
	//2. 计算图像角度 
    int orientation = ImageHeaderParserUtils.getOrientation(parsers, is, byteArrayPool); 
    int degreesToRotate = TransformationUtils.getExifOrientationDegrees(orientation); 
    boolean isExifOrientationRequired = TransformationUtils.isExifOrientationRequired(orientation); 
 
	// 设定图像需要的目标大小 
    int targetWidth = requestedWidth == Target.SIZE_ORIGINAL ? sourceWidth : requestedWidth; 
    int targetHeight = requestedHeight == Target.SIZE_ORIGINAL ? sourceHeight : requestedHeight; 
 
    ImageType imageType = ImageHeaderParserUtils.getType(parsers, is, byteArrayPool); 
 
	// 计算调整Option关于inSamplerSize、inScale、inDensity等参数 
    calculateScaling( 
        imageType, 
        is, 
        callbacks, 
        bitmapPool, 
        downsampleStrategy, 
        degreesToRotate, 
        sourceWidth, 
        sourceHeight, 
        targetWidth, 
        targetHeight, 
        options); 
		 
    calculateConfig( 
        is, 
        decodeFormat, 
        isHardwareConfigAllowed, 
        isExifOrientationRequired, 
        options, 
        targetWidth, 
        targetHeight); 
    
    // 重新设定图像最后需要的大小 
    boolean isKitKatOrGreater = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT; 
    if ((options.inSampleSize == 1 || isKitKatOrGreater) && shouldUsePool(imageType)) {
    
      int expectedWidth; 
      int expectedHeight; 
      if (sourceWidth >= 0 && sourceHeight >= 0 
          && fixBitmapToRequestedDimensions && isKitKatOrGreater) {
    
        expectedWidth = targetWidth; 
        expectedHeight = targetHeight; 
      } else {
    
        float densityMultiplier = isScaling(options) 
            ? (float) options.inTargetDensity / options.inDensity : 1f; 
        int sampleSize = options.inSampleSize; 
        int downsampledWidth = (int) Math.ceil(sourceWidth / (float) sampleSize); 
        int downsampledHeight = (int) Math.ceil(sourceHeight / (float) sampleSize); 
        expectedWidth = Math.round(downsampledWidth * densityMultiplier); 
        expectedHeight = Math.round(downsampledHeight * densityMultiplier); 
 
      } 
	  // 如果不是image，或者BitmapFactory无法解析，expectedWidth/expectedHeight都会为-1 
      if (expectedWidth > 0 && expectedHeight > 0) {
    
	    // 设置InBitmap可复用的bitmap 
        setInBitmap(options, bitmapPool, expectedWidth, expectedHeight); 
      } 
    } 
	// 3. 解码 
    Bitmap downsampled = decodeStream(is, options, callbacks, bitmapPool); 
    callbacks.onDecodeComplete(bitmapPool, downsampled); 
 
    Bitmap rotated = null; 
    if (downsampled != null) {
    
	  // 如果缩放过，bitmap的密度inTargetDensity， 等于设定bitmap密度为屏幕的密度 
      downsampled.setDensity(displayMetrics.densityDpi); 
      // 4.旋转图像 
      rotated = TransformationUtils.rotateImageExif(bitmapPool, downsampled, orientation); 
	  if (!downsampled.equals(rotated)) {
    
	  // 加入缓存池 
        bitmapPool.put(downsampled); 
      } 
    } 
 
    return rotated; 
  } 

这里说下Bitmap Options的几个参数：

• inSamplerSize:采样率，2的幂次方
• inDesity: 位图使用的像素密度
• inTargetDesity: 设备的屏幕密度
• inScale: 是否需要放缩位图

inScale设置为true时,且inDenstiy和inTargetDensity也不为0时，位图将在加载时(解码)时放缩去匹配inTargetDensity，在绘制到canvas时不会依赖图像系统放缩。

看完上面的流程，Glide可以说把复用机制用到了极致了，不仅用缓存池，还有上了inBitmap等参数。

这里我只关心几个问题：

1. 计算图像大小

  private static int[] getDimensions(InputStream is, BitmapFactory.Options options, 
      DecodeCallbacks decodeCallbacks, BitmapPool bitmapPool) throws IOException {
    
    options.inJustDecodeBounds = true; 
    decodeStream(is, options, decodeCallbacks, bitmapPool); 
    options.inJustDecodeBounds = false; 
    return new int[] {
    options.outWidth, options.outHeight }; 
  } 

跟日常我们使用的差不多，也是用inJustDecodeBounds参数，不多说

2. 计算图像角度

    int orientation = ImageHeaderParserUtils.getOrientation(parsers, is, byteArrayPool); 
    int degreesToRotate = TransformationUtils.getExifOrientationDegrees(orientation); 

以上说了parsers有两种类型： DefaultImageHeaderParser、 ExifInterfaceImageHeaderParser

DefaultImageHeaderParser是Glide自定义的默认的头部解析器，自己解析头部信息

ExifInterfaceImageHeaderParser 是利用ExifInterface接口，比较有借鉴意义：

// ExifInterfaceImageHeaderParser 
  public int getOrientation(@NonNull InputStream is, @NonNull ArrayPool byteArrayPool) 
      throws IOException {
    
    ExifInterface exifInterface = new ExifInterface(is); 
    int result = exifInterface.getAttributeInt( 
            ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
    if (result == ExifInterface.ORIENTATION_UNDEFINED) {
    
      return ImageHeaderParser.UNKNOWN_ORIENTATION; 
    } 
    return result; 
  } 
   
// TransformationUtils 
  public static int getExifOrientationDegrees(int exifOrientation) {
    
    final int degreesToRotate; 
    switch (exifOrientation) {
    
      case ExifInterface.ORIENTATION_TRANSPOSE: 
      case ExifInterface.ORIENTATION_ROTATE_90: 
        degreesToRotate = 90; 
        break; 
      case ExifInterface.ORIENTATION_ROTATE_180: 
      case ExifInterface.ORIENTATION_FLIP_VERTICAL: 
        degreesToRotate = 180; 
        break; 
      case ExifInterface.ORIENTATION_TRANSVERSE: 
      case ExifInterface.ORIENTATION_ROTATE_270: 
        degreesToRotate = 270; 
        break; 
      default: 
        degreesToRotate = 0; 
        break; 
    } 
    return degreesToRotate; 
  } 

3. 解码

private static Bitmap decodeStream(InputStream is, BitmapFactory.Options options, 
      DecodeCallbacks callbacks, BitmapPool bitmapPool) throws IOException {
    
    if (options.inJustDecodeBounds) {
    
      is.mark(MARK_POSITION); 
    } else {
    
      callbacks.onObtainBounds(); 
    } 
    String outMimeType = options.outMimeType; 
    final Bitmap result; 
    TransformationUtils.getBitmapDrawableLock().lock(); 
    try {
    
      result = BitmapFactory.decodeStream(is, null, options); 
    } catch (IllegalArgumentException e) {
    
		... 
	} 
    if (options.inJustDecodeBounds) {
    
      is.reset(); 
 
    } 
    return result; 
  } 

Glide的解码也是利用了BitmapFactory.decodeStream()。

这里可以学到的是：通过mark和reset可以复用InputStream，这里的InputStream是Glide自己实现的 RecyclableBufferedInputStream

但是FileInputStream是不支持mark和reset的，不过你可以使用BufferedInputStream，它提供“缓冲功能”以及支持“mark()标记”和“reset()重置方法”。本质上通过一个内部缓冲区数组实现的，将输入流的数据分批的填入到缓冲区中，当缓冲区中的数据被读完之后，输入流会再次填充数据缓冲区，如此反复，直到读完。

4.旋转图像

public static Bitmap rotateImageExif(@NonNull BitmapPool pool, @NonNull Bitmap inBitmap, 
      int exifOrientation) {
    
	// 判断是否需要旋转 
    if (!isExifOrientationRequired(exifOrientation)) {
    
      return inBitmap; 
    } 
 
    final Matrix matrix = new Matrix(); 
    initializeMatrixForRotation(exifOrientation, matrix); 
 
    // From Bitmap.createBitmap. 
    final RectF newRect = new RectF(0, 0, inBitmap.getWidth(), inBitmap.getHeight()); 
    matrix.mapRect(newRect); 
 
    final int newWidth = Math.round(newRect.width()); 
    final int newHeight = Math.round(newRect.height()); 
 
    Bitmap.Config config = getNonNullConfig(inBitmap); 
	// 从缓存池获取一个bitmap 
    Bitmap result = pool.get(newWidth, newHeight, config); 
 
    matrix.postTranslate(-newRect.left, -newRect.top); 
    // 绘制一个新的bitmap 
    applyMatrix(inBitmap, result, matrix); 
    return result; 
  } 
   
  // 判断是否需要旋转 
  public static boolean isExifOrientationRequired(int exifOrientation) {
    
    switch (exifOrientation) {
    
      case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: 
      case ExifInterface.ORIENTATION_ROTATE_180: 
      case ExifInterface.ORIENTATION_FLIP_VERTICAL: 
      case ExifInterface.ORIENTATION_TRANSPOSE: 
      case ExifInterface.ORIENTATION_ROTATE_90: 
      case ExifInterface.ORIENTATION_TRANSVERSE: 
      case ExifInterface.ORIENTATION_ROTATE_270: 
        return true; 
      default: 
        return false; 
    } 
  } 
   
  // 利用 matrix 绘制一个新的bitmap 
  private static void applyMatrix(@NonNull Bitmap inBitmap, @NonNull Bitmap targetBitmap, 
      Matrix matrix) {
    
    BITMAP_DRAWABLE_LOCK.lock(); 
    try {
    
      Canvas canvas = new Canvas(targetBitmap); 
      canvas.drawBitmap(inBitmap, matrix, DEFAULT_PAINT); 
      clear(canvas); 
    } finally {
    
      BITMAP_DRAWABLE_LOCK.unlock(); 
    } 
  } 

以上注释蛮清晰简单的，不做过多解释

Glide 怎么保证ImageView宽高？

在《Glide原理解析(一)：加载流程分析》 的SingleRequest的begin()方法里，如果知道了Target的Size就会调用onSizeReady()，如果不知道就会调用Target.getSize()

    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
    
      // 已经拿到了size，可以开始异步请求 
      onSizeReady(overrideWidth, overrideHeight); 
    } else {
    
      // 从Target中获取目标的size，最后会走到onSizeReady() 
      target.getSize(this); 
    } 

我们看一下 ViewTarget.getSize()方法

  // ViewTarget 
  public void getSize(@NonNull SizeReadyCallback cb) {
    
    sizeDeterminer.getSize(cb); 
  } 

sizeDeterminer 是负责获取target的size

// SizeDeterminer 
  void getSize(@NonNull SizeReadyCallback cb) {
    
    int currentWidth = getTargetWidth(); 
    int currentHeight = getTargetHeight(); 
    if (isViewStateAndSizeValid(currentWidth, currentHeight)) {
    
	  // 已经拿到了size，回调出去 
      cb.onSizeReady(currentWidth, currentHeight); 
      return; 
    } 
	// 添加一个回调 
    if (!cbs.contains(cb)) {
    
      cbs.add(cb); 
    } 
	 
    if (layoutListener == null) {
    
      ViewTreeObserver observer = view.getViewTreeObserver(); 
      layoutListener = new SizeDeterminerLayoutListener(this); 
	  // 利用了ViewTreeObserver 
      observer.addOnPreDrawListener(layoutListener); 
    } 
  } 

到这里不需要继续往下看了。

其实就是Glide利用了ViewTreeObserver.OnPreDrawListener，添加到View中，当view绘制之前就会通知Glide。