/**
  * Sets the content of this ImageView to the specified Uri.
  *
  * @param uri The Uri of an image
  */
 public void setImageURI(Uri uri) {
   if (mResource != 0 || (mUri != uri && (uri == null || mUri == null || !uri.equals(mUri)))) {
     updateDrawable(null);
     mResource = 0;
     mUri = uri;
     resolveUri();
     requestLayout();
     invalidate();
   }
 }
 /**
  * Sets a drawable as the content of this ImageView.
  *
  * @param resId the resource identifier of the the drawable
  * @attr ref android.R.styleable#ImageView_src
  */
 public void setImageResource(int resId) {
   if (mUri != null || mResource != resId) {
     updateDrawable(null);
     mResource = resId;
     mUri = null;
     resolveUri();
     requestLayout();
     invalidate();
   }
 }
  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    resolveUri();
    int w;
    int h;

    // Desired aspect ratio of the view's contents (not including padding)
    float desiredAspect = 0.0f;

    // We are allowed to change the view's width
    boolean resizeWidth = false;

    // We are allowed to change the view's height
    boolean resizeHeight = false;

    if (mDrawable == null) {
      // If no drawable, its intrinsic size is 0.
      mDrawableWidth = -1;
      mDrawableHeight = -1;
      w = h = 0;
    } else {
      w = mDrawableWidth;
      h = mDrawableHeight;
      if (w <= 0) w = 1;
      if (h <= 0) h = 1;

      // We are supposed to adjust view bounds to match the aspect
      // ratio of our drawable. See if that is possible.
      if (mAdjustViewBounds) {

        int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);

        resizeWidth = widthSpecMode != MeasureSpec.EXACTLY;
        resizeHeight = heightSpecMode != MeasureSpec.EXACTLY;

        desiredAspect = (float) w / (float) h;
      }
    }

    int pleft = mPaddingLeft;
    int pright = mPaddingRight;
    int ptop = mPaddingTop;
    int pbottom = mPaddingBottom;

    int widthSize;
    int heightSize;

    if (resizeWidth || resizeHeight) {
      /* If we get here, it means we want to resize to match the
          drawables aspect ratio, and we have the freedom to change at
          least one dimension.
      */

      // Get the max possible width given our constraints
      widthSize = resolveAdjustedSize(w + pleft + pright, mMaxWidth, widthMeasureSpec);

      // Get the max possible height given our constraints
      heightSize = resolveAdjustedSize(h + ptop + pbottom, mMaxHeight, heightMeasureSpec);

      if (desiredAspect != 0.0f) {
        // See what our actual aspect ratio is
        float actualAspect = (float) (widthSize - pleft - pright) / (heightSize - ptop - pbottom);

        if (Math.abs(actualAspect - desiredAspect) > 0.0000001) {

          boolean done = false;

          // Try adjusting width to be proportional to height
          if (resizeWidth) {
            int newWidth = (int) (desiredAspect * (heightSize - ptop - pbottom)) + pleft + pright;
            if (newWidth <= widthSize) {
              widthSize = newWidth;
              done = true;
            }
          }

          // Try adjusting height to be proportional to width
          if (!done && resizeHeight) {
            int newHeight = (int) ((widthSize - pleft - pright) / desiredAspect) + ptop + pbottom;
            if (newHeight <= heightSize) {
              heightSize = newHeight;
            }
          }
        }
      }
    } else {
      /* We are either don't want to preserve the drawables aspect ratio,
         or we are not allowed to change view dimensions. Just measure in
         the normal way.
      */
      w += pleft + pright;
      h += ptop + pbottom;

      w = Math.max(w, getSuggestedMinimumWidth());
      h = Math.max(h, getSuggestedMinimumHeight());

      widthSize = resolveSize(w, widthMeasureSpec);
      heightSize = resolveSize(h, heightMeasureSpec);
    }

    setMeasuredDimension(widthSize, heightSize);
  }