ImageView源码解读

Qusetions

How setScaleType？

setScaleType in conjunction with setFrame

setScaleType

/**
 * Controls how the image should be resized or moved to match the size
 * of this ImageView.
 * 
 * @param scaleType The desired scaling mode.
 * 
 * @attr ref android.R.styleable#ImageView_scaleType
 * normal step
 * 1.store mScaleType
 * 2.setWillNotCacheDrawing//how to work this method
    /##
    v.setDrawingCacheEnabled(true);
    v.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
    MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));//this is the important code
    Without it the view will have a dimension of 0,0 and the bitmap will be null
    v.layout(0, 0, v.getMeasuredWidth(), v.getMeasuredHeight());
    v.buildDrawingCache(true);
    Bitmap b = Bitmap.createBitmap(v.getDrawingCache());
    v.setDrawingCacheEnabled(false); // clear drawing cache
    ##/
   @seeNext View.draw()->View.getDrawingCache()
   @seeNext View.buildDrawingCacheImpl()
 * 3.requestLayout and invalidate
 */
public void setScaleType(ScaleType scaleType) {
    if (scaleType == null) {
        throw new NullPointerException();
    }

    if (mScaleType != scaleType) {
        mScaleType = scaleType;

        setWillNotCacheDrawing(mScaleType == ScaleType.CENTER);            

        requestLayout();
        invalidate();
    }
}




/**
 * This method is called by ViewGroup.drawChild() to have each child view draw itself.
 *
 * This is where the View specializes rendering behavior based on layer type,
 * and hardware acceleration.
 */
boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
   ......
    Bitmap cache = null;
    int layerType = getLayerType(); // TODO: signify cache state with just 'cache' local
    if (layerType == LAYER_TYPE_SOFTWARE
            || (!drawingWithRenderNode && layerType != LAYER_TYPE_NONE)) {
        // If not drawing with RenderNode, treat HW layers as SW
        layerType = LAYER_TYPE_SOFTWARE;
        buildDrawingCache(true);
        cache = getDrawingCache(true);
    }

    ......

    if (!drawingWithDrawingCache) {
    ......
    } else if (cache != null) {
        mPrivateFlags &= ~PFLAG_DIRTY_MASK;
        if (layerType == LAYER_TYPE_NONE) {
            // no layer paint, use temporary paint to draw bitmap
            Paint cachePaint = parent.mCachePaint;
            if (cachePaint == null) {
                cachePaint = new Paint();
                cachePaint.setDither(false);
                parent.mCachePaint = cachePaint;
            }
            cachePaint.setAlpha((int) (alpha * 255));
            canvas.drawBitmap(cache, 0.0f, 0.0f, cachePaint);
        } else {
            // use layer paint to draw the bitmap, merging the two alphas, but also restore
            int layerPaintAlpha = mLayerPaint.getAlpha();
            mLayerPaint.setAlpha((int) (alpha * layerPaintAlpha));
            canvas.drawBitmap(cache, 0.0f, 0.0f, mLayerPaint);
            mLayerPaint.setAlpha(layerPaintAlpha);
        }
    }
  
  
  
    /**
 * <p>Returns the bitmap in which this view drawing is cached. The returned bitmap
 * is null when caching is disabled. If caching is enabled and the cache is not ready,
 * this method will create it. Calling {@link #draw(android.graphics.Canvas)} will not
 * draw from the cache when the cache is enabled. To benefit from the cache, you must
 * request the drawing cache by calling this method and draw it on screen if the
 * returned bitmap is not null.</p>
 *
 * <p>Note about auto scaling in compatibility mode: When auto scaling is not enabled,
 * this method will create a bitmap of the same size as this view. Because this bitmap
 * will be drawn scaled by the parent ViewGroup, the result on screen might show
 * scaling artifacts. To avoid such artifacts, you should call this method by setting
 * the auto scaling to true. Doing so, however, will generate a bitmap of a different
 * size than the view. This implies that your application must be able to handle this
 * size.</p>
 *
 * @param autoScale Indicates whether the generated bitmap should be scaled based on
 *        the current density of the screen when the application is in compatibility
 *        mode.
 *
 * @return A bitmap representing this view or null if cache is disabled.
 *
 * @see #setDrawingCacheEnabled(boolean)
 * @see #isDrawingCacheEnabled()
 * @see #buildDrawingCache(boolean)
 * @see #destroyDrawingCache()
 */
public Bitmap getDrawingCache(boolean autoScale) {
  //setScaleType funtion here
    if ((mViewFlags & WILL_NOT_CACHE_DRAWING) == WILL_NOT_CACHE_DRAWING) {
        return null;
    }
    if ((mViewFlags & DRAWING_CACHE_ENABLED) == DRAWING_CACHE_ENABLED) {
        buildDrawingCache(autoScale);
    }
    return autoScale ? mDrawingCache : mUnscaledDrawingCache;
}
  
  
  /**
 * private, internal implementation of buildDrawingCache, used to enable tracing
 */
private void buildDrawingCacheImpl(boolean autoScale) {
    mCachingFailed = false;

    int width = mRight - mLeft;
    int height = mBottom - mTop;

    final AttachInfo attachInfo = mAttachInfo;
    final boolean scalingRequired = attachInfo != null && attachInfo.mScalingRequired;

    if (autoScale && scalingRequired) {
        width = (int) ((width * attachInfo.mApplicationScale) + 0.5f);
        height = (int) ((height * attachInfo.mApplicationScale) + 0.5f);
    }

    final int drawingCacheBackgroundColor = mDrawingCacheBackgroundColor;
    final boolean opaque = drawingCacheBackgroundColor != 0 || isOpaque();
    final boolean use32BitCache = attachInfo != null && attachInfo.mUse32BitDrawingCache;

    final long projectedBitmapSize = width * height * (opaque && !use32BitCache ? 2 : 4);
    final long drawingCacheSize =
            ViewConfiguration.get(mContext).getScaledMaximumDrawingCacheSize();
    if (width <= 0 || height <= 0 || projectedBitmapSize > drawingCacheSize) {
        if (width > 0 && height > 0) {
            Log.w(VIEW_LOG_TAG, getClass().getSimpleName() + " not displayed because it is"
                    + " too large to fit into a software layer (or drawing cache), needs "
                    + projectedBitmapSize + " bytes, only "
                    + drawingCacheSize + " available");
        }
        destroyDrawingCache();
        mCachingFailed = true;
      // if view is not Measured ,return here
        return;
    }

......
}

setFrame

@Override
protected boolean setFrame(int l, int t, int r, int b) {
    boolean changed = super.setFrame(l, t, r, b);
    mHaveFrame = true;
    configureBounds();//imageView core method
    return changed;
}

How setSrc and setBackground?

• setBackGround: same as View

• setSrc: add a new parameter mDrawable and provider the four methods

  setImageResource

  setImageURI
  setImageDrawable
  setImageBitmap

  above all use the method configureBounds and then come to our slight by onDraw.

  give “setImageDrawable” as an Example.

setImageResource

/**
   * Sets a drawable as the content of this ImageView.
   *
   * <p class="note">This does Bitmap reading and decoding on the UI
   * thread, which can cause a latency hiccup.  If that's a concern,
   * consider using {@link #setImageDrawable(android.graphics.drawable.Drawable)} or
   * {@link #setImageBitmap(android.graphics.Bitmap)} and
   * {@link android.graphics.BitmapFactory} instead.</p>
   *
   * @param resId the resource identifier of the drawable
   *
   * @attr ref android.R.styleable#ImageView_src
   *
   *
   * ##normal  steps
   * 1.store the oldWidth oldHeight
   * 2.updateDrawable (eg:callback,level ,bounds ,scaleType etc.)
   * 3.maybe you have to resolveUri which to decode the res
   * 4.at last requestLayout and then invalidate
   *@seeNext updateDrawable()->configureBounds()
   */
  @android.view.RemotableViewMethod
  public void setImageResource(@DrawableRes int resId) {
      // The resource configuration may have changed, so we should always
      // try to load the resource even if the resId hasn't changed.
      final int oldWidth = mDrawableWidth;
      final int oldHeight = mDrawableHeight;

      updateDrawable(null);
      mResource = resId;
      mUri = null;

      resolveUri();

      if (oldWidth != mDrawableWidth || oldHeight != mDrawableHeight) {
          requestLayout();
      }
      invalidate();
  }

updateDrawable

private void updateDrawable(Drawable d) {
      if (d != mRecycleableBitmapDrawable && mRecycleableBitmapDrawable != null) {
          mRecycleableBitmapDrawable.setBitmap(null);
      }

      if (mDrawable != null) {
          mDrawable.setCallback(null);
          unscheduleDrawable(mDrawable);
      }

      mDrawable = d;

      if (d != null) {
          d.setCallback(this);
          d.setLayoutDirection(getLayoutDirection());
          if (d.isStateful()) {
              d.setState(getDrawableState());
          }
          d.setVisible(getVisibility() == VISIBLE, true);
          d.setLevel(mLevel);
          mDrawableWidth = d.getIntrinsicWidth();
          mDrawableHeight = d.getIntrinsicHeight();
          applyImageTint();
          applyColorMod();

          configureBounds();
      } else {
          mDrawableWidth = mDrawableHeight = -1;
      }
  }

configBounds

private void configureBounds() {
      if (mDrawable == null || !mHaveFrame) {
          return;
      }

      int dwidth = mDrawableWidth;
      int dheight = mDrawableHeight;

      int vwidth = getWidth() - mPaddingLeft - mPaddingRight;
      int vheight = getHeight() - mPaddingTop - mPaddingBottom;

      boolean fits = (dwidth < 0 || vwidth == dwidth) &&
                     (dheight < 0 || vheight == dheight);

      //type 1 :fit_xy = just fill our entire view
      if (dwidth <= 0 || dheight <= 0 || ScaleType.FIT_XY == mScaleType) {
          /* If the drawable has no intrinsic size, or we're told to
              scaletofit, then we just fill our entire view.
          */
          mDrawable.setBounds(0, 0, vwidth, vheight);
          mDrawMatrix = null;
      } else {
          // We need to do the scaling ourself, so have the drawable
          // use its native size.
          mDrawable.setBounds(0, 0, dwidth, dheight);

          //type 2 :matrix =  use special matrix
          if (ScaleType.MATRIX == mScaleType) {
              // Use the specified matrix as-is.
              if (mMatrix.isIdentity()) {
                  mDrawMatrix = null;
              } else {
                  mDrawMatrix = mMatrix;
              }
          } else if (fits) {
              // The bitmap fits exactly, no transform needed.
              mDrawMatrix = null;
          } else if (ScaleType.CENTER == mScaleType) {
              //type 3: center = move  the src center to the view center
              // Center bitmap in view, no scaling.
              mDrawMatrix = mMatrix;
              mDrawMatrix.setTranslate(Math.round((vwidth - dwidth) * 0.5f),
                                       Math.round((vheight - dheight) * 0.5f));
          } else if (ScaleType.CENTER_CROP == mScaleType) {
              //type 4:center_crop=scale and the move the src center to the view center
              //
              mDrawMatrix = mMatrix;

              float scale;
              float dx = 0, dy = 0;

              // other: if(vheihgt/dheight > vwidth/dwidth) chos max
              if (dwidth * vheight > vwidth * dheight) {
                  scale = (float) vheight / (float) dheight; 
                  dx = (vwidth - dwidth * scale) * 0.5f;
              } else {
                  scale = (float) vwidth / (float) dwidth;
                  dy = (vheight - dheight * scale) * 0.5f;
              }

              mDrawMatrix.setScale(scale, scale);
              mDrawMatrix.postTranslate(Math.round(dx), Math.round(dy));
          } else if (ScaleType.CENTER_INSIDE == mScaleType) {
              mDrawMatrix = mMatrix;
              float scale;
              float dx;
              float dy;
              
              if (dwidth <= vwidth && dheight <= vheight) {
                  scale = 1.0f;
              } else {
                  //other : choose min
                  scale = Math.min((float) vwidth / (float) dwidth,
                          (float) vheight / (float) dheight);
              }
              
              dx = Math.round((vwidth - dwidth * scale) * 0.5f);
              dy = Math.round((vheight - dheight * scale) * 0.5f);

              mDrawMatrix.setScale(scale, scale);
              mDrawMatrix.postTranslate(dx, dy);
          } else {
              // Generate the required transform.
              mTempSrc.set(0, 0, dwidth, dheight);
              mTempDst.set(0, 0, vwidth, vheight);
              
              mDrawMatrix = mMatrix;
              mDrawMatrix.setRectToRect(mTempSrc, mTempDst, scaleTypeToScaleToFit(mScaleType));
          }
      }
  }

onDraw

/**
*
*simply apply mDrawMatrix(set by setImageMatrix) and then draw the canvas
**/
 @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        if (mDrawable == null) {
            return; // couldn't resolve the URI
        }

        if (mDrawableWidth == 0 || mDrawableHeight == 0) {
            return;     // nothing to draw (empty bounds)
        }

        if (mDrawMatrix == null && mPaddingTop == 0 && mPaddingLeft == 0) {
            mDrawable.draw(canvas);
        } else {
            int saveCount = canvas.getSaveCount();
            canvas.save();
            
            if (mCropToPadding) {
                final int scrollX = mScrollX;
                final int scrollY = mScrollY;
                canvas.clipRect(scrollX + mPaddingLeft, scrollY + mPaddingTop,
                        scrollX + mRight - mLeft - mPaddingRight,
                        scrollY + mBottom - mTop - mPaddingBottom);
            }
            
            canvas.translate(mPaddingLeft, mPaddingTop);

            // here to effect the final slight
            if (mDrawMatrix != null) {
                canvas.concat(mDrawMatrix);
            }
            mDrawable.draw(canvas);
            canvas.restoreToCount(saveCount);
        }
    }