public void setBackgroundResource(@DrawableRes int resid) {
    if (resid != 0 && resid == mBackgroundResource) {
        return;
  }
    Drawable d = null;
 if (resid != 0) {
        d = mContext.getDrawable(resid);
  }
    setBackground(d);    mBackgroundResource = resid; }
public void setBackground(Drawable background) {
    //noinspection deprecation
  setBackgroundDrawable(background); }

public void setBackgroundDrawable(Drawable background) {
    computeOpaqueFlags();   if (background == mBackground) {
        return;
  }
    boolean requestLayout = false;    mBackgroundResource = 0;    /*
 * Regardless of whether we're setting a new background or not, we want * to clear the previous drawable. setVisible first while we still have the callback set. */  if (mBackground != null) {
        if (isAttachedToWindow()) {
            mBackground.setVisible(false, false);
  }
        mBackground.setCallback(null);
  unscheduleDrawable(mBackground);
  }
    if (background != null) {
        Rect padding = sThreadLocal.get();
 if (padding == null) {
            padding = new Rect();
  sThreadLocal.set(padding);
  }
        resetResolvedDrawablesInternal();
  background.setLayoutDirection(getLayoutDirection());
 if (background.getPadding(padding)) {
            resetResolvedPaddingInternal();
 switch (background.getLayoutDirection()) {
                case LAYOUT_DIRECTION_RTL:
                    mUserPaddingLeftInitial = padding.right;
  mUserPaddingRightInitial = padding.left;
  internalSetPadding(padding.right, padding.top, padding.left, padding.bottom);
 break; case LAYOUT_DIRECTION_LTR:
                default:
                    mUserPaddingLeftInitial = padding.left;
  mUserPaddingRightInitial = padding.right;
  internalSetPadding(padding.left, padding.top, padding.right, padding.bottom);
  }
            mLeftPaddingDefined = false;
  mRightPaddingDefined = false;
  }
        // Compare the minimum sizes of the old Drawable and the new.  If there isn't an old or
 // if it has a different minimum size, we should layout again  if (mBackground == null
  || mBackground.getMinimumHeight() != background.getMinimumHeight()
                || mBackground.getMinimumWidth() != background.getMinimumWidth()) {
            requestLayout = true;
  }
        // Set mBackground before we set this as the callback and start making other
 // background drawable state change calls. In particular, the setVisible call below // can result in drawables attempting to start animations or otherwise invalidate, // which requires the view set as the callback (us) to recognize the drawable as // belonging to it as per verifyDrawable.  mBackground = background;
 if (background.isStateful()) {
            background.setState(getDrawableState());
  }
        if (isAttachedToWindow()) {
            background.setVisible(getWindowVisibility() == VISIBLE && isShown(), false);
  }
        applyBackgroundTint();    // Set callback last, since the view may still be initializing.
  background.setCallback(this);   if ((mPrivateFlags & PFLAG_SKIP_DRAW) != 0) {
            mPrivateFlags &= ~PFLAG_SKIP_DRAW;
  requestLayout = true;
  }
    } else {
        /* Remove the background */
  mBackground = null;
 if ((mViewFlags & WILL_NOT_DRAW) != 0
  && (mForegroundInfo == null || mForegroundInfo.mDrawable == null)) {
            mPrivateFlags |= PFLAG_SKIP_DRAW;
  }
        /*
 * When the background is set, we try to apply its padding to this * View. When the background is removed, we don't touch this View's * padding. This is noted in the Javadocs. Hence, we don't need to * requestLayout(), the invalidate() below is sufficient. */   // The old background's minimum size could have affected this // View's layout, so let's requestLayout  requestLayout = true;
  }
    computeOpaqueFlags();   if (requestLayout) {
        requestLayout();
  }
    mBackgroundSizeChanged = true;
  invalidate(true);
  invalidateOutline(); }

public Bitmap decodeSimpleBitmapFromResource(Resources res, int resId,
 int reqWidth, int reqHeight) {
    BitmapFactory.Options options = new BitmapFactory.Options();
  options.inJustDecodeBounds = true;
  BitmapFactory.decodeResource(res, resId, options);    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);    options.inJustDecodeBounds = false;
 return BitmapFactory.decodeResource(res,resId,options); }
private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    int outWidth = options.outWidth;
 int outHeight = options.outHeight;   int sampleSize = 1;   if (outHeight > outWidth || outWidth > outHeight) {
        int halfWidth = outWidth / 2;
 int halfHeight = outHeight / 2;   while ((halfHeight / sampleSize) >= reqHeight &&
                (halfWidth / sampleSize) >= reqWidth) {
            sampleSize *= 2;
  }
    }
    return sampleSize; }

/**
 * If set to true, the decoder will return null (no bitmap), but * the out... fields will still be set, allowing the caller to query * the bitmap without having to allocate the memory for its pixels. */ public boolean inJustDecodeBounds;

/**
 * If set to a value > 1, requests the decoder to subsample the original * image, returning a smaller image to save memory. The sample size is * the number of pixels in either dimension that correspond to a single * pixel in the decoded bitmap. For example, inSampleSize == 4 returns * an image that is 1/4 the width/height of the original, and 1/16 the * number of pixels. Any value <= 1 is treated the same as 1. Note: the * decoder uses a final value based on powers of 2, any other value will * be rounded down to the nearest power of 2. */ public int inSampleSize;