Android ImageView设置图片原理（上）

 本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！

首先关于图片加载到ImageView上，我们来讨论几个问题：

如下：

imageView.setImageResource(resId);获得图片资源运行在主线程

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 the drawable
     *
     * @attr ref android.R.styleable#ImageView_src
     */
    @android.view.RemotableViewMethod
    public void setImageResource(int resId) {
        if (mUri != null || mResource != resId) {
            updateDrawable(null);
            mResource = resId;
            mUri = null;
            resolveUri();
            requestLayout();
            invalidate();
        }
    }

private void resolveUri() {
     if (mDrawable != null) {
         return;
     }

     Resources rsrc = getResources();
     if (rsrc == null) {
         return;
     }

     Drawable d = null;

     if (mResource != 0) {
         try {
             d = rsrc.getDrawable(mResource);
         } catch (Exception e) {
             Log.w("ImageView", "Unable to find resource: " + mResource, e);
             // Don't try again.
             mUri = null;
         }
     } else if (mUri != null) {

从源码上看，mResource不为空，而mUri不为空，所以下面的方法咱们只贴出来一部分，可以看到，图片drawable值是通过Resource对象在UI线程中完成。方法上面的解释也可佐证，同时引出下面两个问题，由于SetImageResource会使UI线程延迟，所以可以考虑下面两种做法

imageView.setImageDrawable(drawable);获得图片资源运行在子线程

/**
 * Sets a drawable as the content of this ImageView.
 *
 * @param drawable The drawable to set
 */
public void setImageDrawable(Drawable drawable) {
    if (mDrawable != drawable) {
        mResource = 0;
        mUri = null;

        int oldWidth = mDrawableWidth;
        int oldHeight = mDrawableHeight;

        updateDrawable(drawable);

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

private void updateDrawable(Drawable d) {
    if (mDrawable != null) {
        mDrawable.setCallback(null);
        unscheduleDrawable(mDrawable);
    }
    mDrawable = d;
    if (d != null) {
        d.setCallback(this);
        if (d.isStateful()) {
            d.setState(getDrawableState());
        }
        d.setLevel(mLevel);
        mDrawableWidth = d.getIntrinsicWidth();
        mDrawableHeight = d.getIntrinsicHeight();
        applyColorMod();
        configureBounds();
    } else {
        mDrawableWidth = mDrawableHeight = -1;
    }
}

从源码上看，只需要把获得的值，解析一下，刷新到UI线程即可，所以Drawable对象可以在子线程中获取。

imageView.setImageBitmap(bm);获得图片资源可以运行在子线程，且可以改变图片大小

/**
 * Sets a Bitmap as the content of this ImageView.
 *
 * @param bm The bitmap to set
 */
@android.view.RemotableViewMethod
public void setImageBitmap(Bitmap bm) {
    // if this is used frequently, may handle bitmaps explicitly
    // to reduce the intermediate drawable object
    setImageDrawable(new BitmapDrawable(mContext.getResources(), bm));
}

/**
 * Create drawable from a bitmap, setting initial target density based on
 * the display metrics of the resources.
 */
public BitmapDrawable(Resources res, Bitmap bitmap) {
    this(new BitmapState(bitmap), res);
    mBitmapState.mTargetDensity = mTargetDensity;
}

private BitmapDrawable(BitmapState state, Resources res) {
      mBitmapState = state;
      if (res != null) {
          mTargetDensity = res.getDisplayMetrics().densityDpi;
      } else {
          mTargetDensity = state.mTargetDensity;
      }
      setBitmap(state != null ? state.mBitmap : null);
  }

private void setBitmap(Bitmap bitmap) {
    if (bitmap != mBitmap) {
        mBitmap = bitmap;
        if (bitmap != null) {
            computeBitmapSize();
        } else {
            mBitmapWidth = mBitmapHeight = -1;
        }
        invalidateSelf();
    }
}

SetImageBitmap同理，其实是通过BitmapDrawable获得一个Drawable对象，同setImageDrawable。值可以在子线程获得，在主界面刷新。

与此同时，有两个方法出现频率比较高，requestLayout和invalidate方法。

requestLayout：

/**
 * Call this when something has changed which has invalidated the
 * layout of this view. This will schedule a layout pass of the view
 * tree.
 */
public void requestLayout() {
    if (ViewDebug.TRACE_HIERARCHY) {
        ViewDebug.trace(this, ViewDebug.HierarchyTraceType.REQUEST_LAYOUT);
    }

    mPrivateFlags |= FORCE_LAYOUT;
    mPrivateFlags |= INVALIDATED;

    if (mParent != null) {
        if (mLayoutParams != null) {
            mLayoutParams.resolveWithDirection(getResolvedLayoutDirection());
        }
        if (!mParent.isLayoutRequested()) {
            mParent.requestLayout();
        }
    }
}

* To intiate a layout, call {@link #requestLayout}. This method is typically
* called by a view on itself when it believes that is can no longer fit within
* its current bounds.

最主要的是这句，主要是当前View已经放不用所存放的值时，需要重新计算宽高

Invalidate()：

/**
  * Invalidate the whole view. If the view is visible,
  * {@link #onDraw(android.graphics.Canvas)} will be called at some point in
  * the future. This must be called from a UI thread. To call from a non-UI thread,
  * call {@link #postInvalidate()}.
  */
 public void invalidate() {
     invalidate(true);
 }

/**
 * This is where the invalidate() work actually happens. A full invalidate()
 * causes the drawing cache to be invalidated, but this function can be called with
 * invalidateCache set to false to skip that invalidation step for cases that do not
 * need it (for example, a component that remains at the same dimensions with the same
 * content).
 *
 * @param invalidateCache Whether the drawing cache for this view should be invalidated as
 * well. This is usually true for a full invalidate, but may be set to false if the
 * View's contents or dimensions have not changed.
 */
void invalidate(boolean invalidateCache) {
    if (ViewDebug.TRACE_HIERARCHY) {
        ViewDebug.trace(this, ViewDebug.HierarchyTraceType.INVALIDATE);
    }

    if (skipInvalidate()) {
        return;
    }
    if ((mPrivateFlags & (DRAWN | HAS_BOUNDS)) == (DRAWN | HAS_BOUNDS) ||
            (invalidateCache && (mPrivateFlags & DRAWING_CACHE_VALID) == DRAWING_CACHE_VALID) ||
            (mPrivateFlags & INVALIDATED) != INVALIDATED || isOpaque() != mLastIsOpaque) {
        mLastIsOpaque = isOpaque();
        mPrivateFlags &= ~DRAWN;
        mPrivateFlags |= DIRTY;
        if (invalidateCache) {
            mPrivateFlags |= INVALIDATED;
            mPrivateFlags &= ~DRAWING_CACHE_VALID;
        }
        final AttachInfo ai = mAttachInfo;
        final ViewParent p = mParent;
        //noinspection PointlessBooleanExpression,ConstantConditions
        if (!HardwareRenderer.RENDER_DIRTY_REGIONS) {
            if (p != null && ai != null && ai.mHardwareAccelerated) {
                // fast-track for GL-enabled applications; just invalidate the whole hierarchy
                // with a null dirty rect, which tells the ViewAncestor to redraw everything
                p.invalidateChild(this, null);
                return;
            }
        }

        if (p != null && ai != null) {
            final Rect r = ai.mTmpInvalRect;
            r.set(0, 0, mRight - mLeft, mBottom - mTop);
            // Don't call invalidate -- we don't want to internally scroll
            // our own bounds
            p.invalidateChild(this, r);
        }
    }
}

把计算宽高、实际宽高、布局等刷新进来

If either {@link #requestLayout()} or {@link #invalidate()} were called,
 * the framework will take care of measuring, laying out, and drawing the tree
 * as appropriate.

与此同时，我们还可以看到一个知识点postInvalidate

/**
  * <p>Cause an invalidate to happen on a subsequent cycle through the event loop.
  * Use this to invalidate the View from a non-UI thread.</p>
  *
  * <p>This method can be invoked from outside of the UI thread
  * only when this View is attached to a window.</p>
  *
  * @see #invalidate()
  */
 public void postInvalidate() {
     postInvalidateDelayed(0);
 }

/**
 * <p>Cause an invalidate to happen on a subsequent cycle through the event
 * loop. Waits for the specified amount of time.</p>
 *
 * <p>This method can be invoked from outside of the UI thread
 * only when this View is attached to a window.</p>
 *
 * @param delayMilliseconds the duration in milliseconds to delay the
 *         invalidation by
 */
public void postInvalidateDelayed(long delayMilliseconds) {
    // We try only with the AttachInfo because there's no point in invalidating
    // if we are not attached to our window
    AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        Message msg = Message.obtain();
        msg.what = AttachInfo.INVALIDATE_MSG;
        msg.obj = this;
        attachInfo.mHandler.sendMessageDelayed(msg, delayMilliseconds);
    }
}

这个刷新会排到消息队列去刷新，也就是在空闲时刷新，相对来说可以减少阻塞，此任务优先级稍低，当然我们可以加入延迟时间来相对自定义优先级。

在开发过程中，大概会遇到这样的情况，在布局的时候，需要图片的宽度或长度；或者图片太大，ImageView太小，要做图片压缩；这时就要用到接下来讲到的知识点。

BitmapFactory.Options options = new BitmapFactory.Options();

options.inJustDecodeBounds = true;//API中有说明，此时返回bitmap值为null

bitmap = BitmapFactory.decodeFile(pathName,options);

int height=options.outHeight;//获得图片的高

int width=options.outWidth;//获得图片的宽

options.inJustDecodeBounds=false;//之后设置

bitmap=BitmapFactory.decodeFile(pathName, options);

可获得正确的bitmap值。

 本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！