FileDocCategorySizeDatePackage
BitmapDrawable.javaAPI DocAndroid 5.1 API32629Thu Mar 12 22:22:30 GMT 2015android.graphics.drawable

BitmapDrawable

public class BitmapDrawable extends Drawable
A Drawable that wraps a bitmap and can be tiled, stretched, or aligned. You can create a BitmapDrawable from a file path, an input stream, through XML inflation, or from a {@link android.graphics.Bitmap} object.

It can be defined in an XML file with the <bitmap> element. For more information, see the guide to Drawable Resources.

Also see the {@link android.graphics.Bitmap} class, which handles the management and transformation of raw bitmap graphics, and should be used when drawing to a {@link android.graphics.Canvas}.

attr
ref android.R.styleable#BitmapDrawable_src
attr
ref android.R.styleable#BitmapDrawable_antialias
attr
ref android.R.styleable#BitmapDrawable_filter
attr
ref android.R.styleable#BitmapDrawable_dither
attr
ref android.R.styleable#BitmapDrawable_gravity
attr
ref android.R.styleable#BitmapDrawable_mipMap
attr
ref android.R.styleable#BitmapDrawable_tileMode

Fields Summary
private static final int
DEFAULT_PAINT_FLAGS
private static final int
TILE_MODE_UNDEFINED
private static final int
TILE_MODE_DISABLED
private static final int
TILE_MODE_CLAMP
private static final int
TILE_MODE_REPEAT
private static final int
TILE_MODE_MIRROR
private final android.graphics.Rect
mDstRect
private BitmapState
mBitmapState
private android.graphics.PorterDuffColorFilter
mTintFilter
private int
mTargetDensity
private boolean
mDstRectAndInsetsDirty
private boolean
mMutated
private int
mBitmapWidth
private int
mBitmapHeight
private android.graphics.Insets
mOpticalInsets
Optical insets due to gravity.
private android.graphics.Matrix
mMirrorMatrix
Constructors Summary
public BitmapDrawable()
Create an empty drawable, not dealing with density.

deprecated
Use {@link #BitmapDrawable(android.content.res.Resources, android.graphics.Bitmap)} instead to specify a bitmap to draw with and ensure the correct density is set.


                                     
    
      
        mBitmapState = new BitmapState((Bitmap) null);
public BitmapDrawable(android.content.res.Resources res)
Create an empty drawable, setting initial target density based on the display metrics of the resources.

deprecated
Use {@link #BitmapDrawable(android.content.res.Resources, android.graphics.Bitmap)} instead to specify a bitmap to draw with.

        mBitmapState = new BitmapState((Bitmap) null);
        mBitmapState.mTargetDensity = mTargetDensity;
public BitmapDrawable(android.graphics.Bitmap bitmap)
Create drawable from a bitmap, not dealing with density.

deprecated
Use {@link #BitmapDrawable(Resources, Bitmap)} to ensure that the drawable has correctly set its target density.

        this(new BitmapState(bitmap), null);
public BitmapDrawable(android.content.res.Resources res, android.graphics.Bitmap bitmap)
Create drawable from a bitmap, setting initial target density based on the display metrics of the resources.

        this(new BitmapState(bitmap), res);
        mBitmapState.mTargetDensity = mTargetDensity;
public BitmapDrawable(String filepath)
Create a drawable by opening a given file path and decoding the bitmap.

deprecated
Use {@link #BitmapDrawable(Resources, String)} to ensure that the drawable has correctly set its target density.

        this(new BitmapState(BitmapFactory.decodeFile(filepath)), null);
        if (mBitmapState.mBitmap == null) {
            android.util.Log.w("BitmapDrawable", "BitmapDrawable cannot decode " + filepath);
        }
public BitmapDrawable(android.content.res.Resources res, String filepath)
Create a drawable by opening a given file path and decoding the bitmap.

        this(new BitmapState(BitmapFactory.decodeFile(filepath)), null);
        mBitmapState.mTargetDensity = mTargetDensity;
        if (mBitmapState.mBitmap == null) {
            android.util.Log.w("BitmapDrawable", "BitmapDrawable cannot decode " + filepath);
        }
private BitmapDrawable(BitmapState state, android.content.res.Resources res)
The one constructor to rule them all. This is called by all public constructors to set the state and initialize local properties.

        mBitmapState = state;

        initializeWithState(mBitmapState, res);
public BitmapDrawable(InputStream is)
Create a drawable by decoding a bitmap from the given input stream.

deprecated
Use {@link #BitmapDrawable(Resources, java.io.InputStream)} to ensure that the drawable has correctly set its target density.

        this(new BitmapState(BitmapFactory.decodeStream(is)), null);
        if (mBitmapState.mBitmap == null) {
            android.util.Log.w("BitmapDrawable", "BitmapDrawable cannot decode " + is);
        }
public BitmapDrawable(android.content.res.Resources res, InputStream is)
Create a drawable by decoding a bitmap from the given input stream.

        this(new BitmapState(BitmapFactory.decodeStream(is)), null);
        mBitmapState.mTargetDensity = mTargetDensity;
        if (mBitmapState.mBitmap == null) {
            android.util.Log.w("BitmapDrawable", "BitmapDrawable cannot decode " + is);
        }
Methods Summary
public voidapplyTheme(android.content.res.Resources.Theme t)

        super.applyTheme(t);

        final BitmapState state = mBitmapState;
        if (state == null || state.mThemeAttrs == null) {
            return;
        }

        final TypedArray a = t.resolveAttributes(state.mThemeAttrs, R.styleable.BitmapDrawable);
        try {
            updateStateFromTypedArray(a);
        } catch (XmlPullParserException e) {
            throw new RuntimeException(e);
        } finally {
            a.recycle();
        }
public booleancanApplyTheme()

        return mBitmapState != null && mBitmapState.mThemeAttrs != null;
public voidclearMutated()

hide

        super.clearMutated();
        mMutated = false;
private voidcomputeBitmapSize()

        final Bitmap bitmap = mBitmapState.mBitmap;
        if (bitmap != null) {
            mBitmapWidth = bitmap.getScaledWidth(mTargetDensity);
            mBitmapHeight = bitmap.getScaledHeight(mTargetDensity);
        } else {
            mBitmapWidth = mBitmapHeight = -1;
        }
public voiddraw(android.graphics.Canvas canvas)

        final Bitmap bitmap = mBitmapState.mBitmap;
        if (bitmap == null) {
            return;
        }

        final BitmapState state = mBitmapState;
        final Paint paint = state.mPaint;
        if (state.mRebuildShader) {
            final Shader.TileMode tmx = state.mTileModeX;
            final Shader.TileMode tmy = state.mTileModeY;
            if (tmx == null && tmy == null) {
                paint.setShader(null);
            } else {
                paint.setShader(new BitmapShader(bitmap,
                        tmx == null ? Shader.TileMode.CLAMP : tmx,
                        tmy == null ? Shader.TileMode.CLAMP : tmy));
            }

            state.mRebuildShader = false;
        }

        final int restoreAlpha;
        if (state.mBaseAlpha != 1.0f) {
            final Paint p = getPaint();
            restoreAlpha = p.getAlpha();
            p.setAlpha((int) (restoreAlpha * state.mBaseAlpha + 0.5f));
        } else {
            restoreAlpha = -1;
        }

        final boolean clearColorFilter;
        if (mTintFilter != null && paint.getColorFilter() == null) {
            paint.setColorFilter(mTintFilter);
            clearColorFilter = true;
        } else {
            clearColorFilter = false;
        }

        updateDstRectAndInsetsIfDirty();
        final Shader shader = paint.getShader();
        final boolean needMirroring = needMirroring();
        if (shader == null) {
            if (needMirroring) {
                canvas.save();
                // Mirror the bitmap
                canvas.translate(mDstRect.right - mDstRect.left, 0);
                canvas.scale(-1.0f, 1.0f);
            }

            canvas.drawBitmap(bitmap, null, mDstRect, paint);

            if (needMirroring) {
                canvas.restore();
            }
        } else {
            if (needMirroring) {
                // Mirror the bitmap
                updateMirrorMatrix(mDstRect.right - mDstRect.left);
                shader.setLocalMatrix(mMirrorMatrix);
                paint.setShader(shader);
            } else {
                if (mMirrorMatrix != null) {
                    mMirrorMatrix = null;
                    shader.setLocalMatrix(Matrix.IDENTITY_MATRIX);
                    paint.setShader(shader);
                }
            }

            canvas.drawRect(mDstRect, paint);
        }

        if (clearColorFilter) {
            paint.setColorFilter(null);
        }

        if (restoreAlpha >= 0) {
            paint.setAlpha(restoreAlpha);
        }
public intgetAlpha()

        return mBitmapState.mPaint.getAlpha();
public final android.graphics.BitmapgetBitmap()
Returns the bitmap used by this drawable to render. May be null.

        return mBitmapState.mBitmap;
public intgetChangingConfigurations()

        return super.getChangingConfigurations() | mBitmapState.mChangingConfigurations;
public android.graphics.ColorFiltergetColorFilter()

        return mBitmapState.mPaint.getColorFilter();
public final ConstantStategetConstantState()

        mBitmapState.mChangingConfigurations = getChangingConfigurations();
        return mBitmapState;
public intgetGravity()
Get the gravity used to position/stretch the bitmap within its bounds. See android.view.Gravity

return
the gravity applied to the bitmap

        return mBitmapState.mGravity;
public intgetIntrinsicHeight()

        return mBitmapHeight;
public intgetIntrinsicWidth()

        return mBitmapWidth;
public intgetOpacity()

        if (mBitmapState.mGravity != Gravity.FILL) {
            return PixelFormat.TRANSLUCENT;
        }

        final Bitmap bitmap = mBitmapState.mBitmap;
        return (bitmap == null || bitmap.hasAlpha() || mBitmapState.mPaint.getAlpha() < 255) ?
                PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE;
public android.graphics.InsetsgetOpticalInsets()

hide

        updateDstRectAndInsetsIfDirty();
        return mOpticalInsets;
public voidgetOutline(android.graphics.Outline outline)

        updateDstRectAndInsetsIfDirty();
        outline.setRect(mDstRect);

        // Only opaque Bitmaps can report a non-0 alpha,
        // since only they are guaranteed to fill their bounds
        boolean opaqueOverShape = mBitmapState.mBitmap != null
                && !mBitmapState.mBitmap.hasAlpha();
        outline.setAlpha(opaqueOverShape ? getAlpha() / 255.0f : 0.0f);
public final android.graphics.PaintgetPaint()
Returns the paint used to render this drawable.

        return mBitmapState.mPaint;
public Shader.TileModegetTileModeX()
Indicates the repeat behavior of this drawable on the X axis.

return
{@link android.graphics.Shader.TileMode#CLAMP} if the bitmap does not repeat, {@link android.graphics.Shader.TileMode#REPEAT} or {@link android.graphics.Shader.TileMode#MIRROR} otherwise.

        return mBitmapState.mTileModeX;
public Shader.TileModegetTileModeY()
Indicates the repeat behavior of this drawable on the Y axis.

return
{@link android.graphics.Shader.TileMode#CLAMP} if the bitmap does not repeat, {@link android.graphics.Shader.TileMode#REPEAT} or {@link android.graphics.Shader.TileMode#MIRROR} otherwise.

        return mBitmapState.mTileModeY;
public android.content.res.ColorStateListgetTint()

hide
only needed by a hack within ProgressBar

        return mBitmapState.mTint;
public android.graphics.PorterDuff.ModegetTintMode()

hide
only needed by a hack within ProgressBar

        return mBitmapState.mTintMode;
public booleanhasAntiAlias()
Indicates whether anti-aliasing is enabled for this drawable.

return
True if anti-aliasing is enabled, false otherwise.
see
#setAntiAlias(boolean)

        return mBitmapState.mPaint.isAntiAlias();
public booleanhasMipMap()
Indicates whether the mipmap hint is enabled on this drawable's bitmap.

return
True if the mipmap hint is set, false otherwise. If the bitmap is null, this method always returns false.
see
#setMipMap(boolean)
attr
ref android.R.styleable#BitmapDrawable_mipMap

        return mBitmapState.mBitmap != null && mBitmapState.mBitmap.hasMipMap();
public voidinflate(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.util.AttributeSet attrs, android.content.res.Resources.Theme theme)

        super.inflate(r, parser, attrs, theme);

        final TypedArray a = obtainAttributes(r, theme, attrs, R.styleable.BitmapDrawable);
        updateStateFromTypedArray(a);
        verifyState(a);
        a.recycle();
private voidinitializeWithState(android.graphics.drawable.BitmapDrawable$BitmapState state, android.content.res.Resources res)
Initializes local dynamic properties from state. This should be called after significant state changes, e.g. from the One True Constructor and after inflating or applying a theme.

        if (res != null) {
            mTargetDensity = res.getDisplayMetrics().densityDpi;
        } else {
            mTargetDensity = state.mTargetDensity;
        }

        mTintFilter = updateTintFilter(mTintFilter, state.mTint, state.mTintMode);
        computeBitmapSize();
public final booleanisAutoMirrored()

        return mBitmapState.mAutoMirrored;
public booleanisStateful()

        final BitmapState s = mBitmapState;
        return super.isStateful() || (s.mTint != null && s.mTint.isStateful());
public Drawablemutate()
A mutable BitmapDrawable still shares its Bitmap with any other Drawable that comes from the same resource.

return
This drawable.

        if (!mMutated && super.mutate() == this) {
            mBitmapState = new BitmapState(mBitmapState);
            mMutated = true;
        }
        return this;
private booleanneedMirroring()

        return isAutoMirrored() && getLayoutDirection() == LayoutDirection.RTL;
protected voidonBoundsChange(android.graphics.Rect bounds)

        mDstRectAndInsetsDirty = true;

        final Shader shader = mBitmapState.mPaint.getShader();
        if (shader != null) {
            if (needMirroring()) {
                updateMirrorMatrix(bounds.right - bounds.left);
                shader.setLocalMatrix(mMirrorMatrix);
                mBitmapState.mPaint.setShader(shader);
            } else {
                if (mMirrorMatrix != null) {
                    mMirrorMatrix = null;
                    shader.setLocalMatrix(Matrix.IDENTITY_MATRIX);
                    mBitmapState.mPaint.setShader(shader);
                }
            }
        }
protected booleanonStateChange(int[] stateSet)

        final BitmapState state = mBitmapState;
        if (state.mTint != null && state.mTintMode != null) {
            mTintFilter = updateTintFilter(mTintFilter, state.mTint, state.mTintMode);
            return true;
        }
        return false;
private static Shader.TileModeparseTileMode(int tileMode)

        switch (tileMode) {
            case TILE_MODE_CLAMP:
                return Shader.TileMode.CLAMP;
            case TILE_MODE_REPEAT:
                return Shader.TileMode.REPEAT;
            case TILE_MODE_MIRROR:
                return Shader.TileMode.MIRROR;
            default:
                return null;
        }
public voidsetAlpha(int alpha)

        final int oldAlpha = mBitmapState.mPaint.getAlpha();
        if (alpha != oldAlpha) {
            mBitmapState.mPaint.setAlpha(alpha);
            invalidateSelf();
        }
public voidsetAntiAlias(boolean aa)
Enables or disables anti-aliasing for this drawable. Anti-aliasing affects the edges of the bitmap only so it applies only when the drawable is rotated.

param
aa True if the bitmap should be anti-aliased, false otherwise.
see
#hasAntiAlias()

        mBitmapState.mPaint.setAntiAlias(aa);
        invalidateSelf();
public voidsetAutoMirrored(boolean mirrored)

        if (mBitmapState.mAutoMirrored != mirrored) {
            mBitmapState.mAutoMirrored = mirrored;
            invalidateSelf();
        }
private voidsetBitmap(android.graphics.Bitmap bitmap)

        if (mBitmapState.mBitmap != bitmap) {
            mBitmapState.mBitmap = bitmap;
            computeBitmapSize();
            invalidateSelf();
        }
public voidsetColorFilter(android.graphics.ColorFilter cf)

        mBitmapState.mPaint.setColorFilter(cf);
        invalidateSelf();
public voidsetDither(boolean dither)

        mBitmapState.mPaint.setDither(dither);
        invalidateSelf();
public voidsetFilterBitmap(boolean filter)

        mBitmapState.mPaint.setFilterBitmap(filter);
        invalidateSelf();
public voidsetGravity(int gravity)
Set the gravity used to position/stretch the bitmap within its bounds. See android.view.Gravity

param
gravity the gravity

        if (mBitmapState.mGravity != gravity) {
            mBitmapState.mGravity = gravity;
            mDstRectAndInsetsDirty = true;
            invalidateSelf();
        }
public voidsetMipMap(boolean mipMap)
Enables or disables the mipmap hint for this drawable's bitmap. See {@link Bitmap#setHasMipMap(boolean)} for more information. If the bitmap is null calling this method has no effect.

param
mipMap True if the bitmap should use mipmaps, false otherwise.
see
#hasMipMap()

        if (mBitmapState.mBitmap != null) {
            mBitmapState.mBitmap.setHasMipMap(mipMap);
            invalidateSelf();
        }
public voidsetTargetDensity(android.graphics.Canvas canvas)
Set the density scale at which this drawable will be rendered. This method assumes the drawable will be rendered at the same density as the specified canvas.

param
canvas The Canvas from which the density scale must be obtained.
see
android.graphics.Bitmap#setDensity(int)
see
android.graphics.Bitmap#getDensity()

        setTargetDensity(canvas.getDensity());
public voidsetTargetDensity(android.util.DisplayMetrics metrics)
Set the density scale at which this drawable will be rendered.

param
metrics The DisplayMetrics indicating the density scale for this drawable.
see
android.graphics.Bitmap#setDensity(int)
see
android.graphics.Bitmap#getDensity()

        setTargetDensity(metrics.densityDpi);
public voidsetTargetDensity(int density)
Set the density at which this drawable will be rendered.

param
density The density scale for this drawable.
see
android.graphics.Bitmap#setDensity(int)
see
android.graphics.Bitmap#getDensity()

        if (mTargetDensity != density) {
            mTargetDensity = density == 0 ? DisplayMetrics.DENSITY_DEFAULT : density;
            if (mBitmapState.mBitmap != null) {
                computeBitmapSize();
            }
            invalidateSelf();
        }
public voidsetTileModeX(Shader.TileMode mode)
Sets the repeat behavior of this drawable on the X axis. By default, the drawable does not repeat its bitmap. Using {@link android.graphics.Shader.TileMode#REPEAT} or {@link android.graphics.Shader.TileMode#MIRROR} the bitmap can be repeated (or tiled) if the bitmap is smaller than this drawable.

param
mode The repeat mode for this drawable.
see
#setTileModeY(android.graphics.Shader.TileMode)
see
#setTileModeXY(android.graphics.Shader.TileMode, android.graphics.Shader.TileMode)
attr
ref android.R.styleable#BitmapDrawable_tileModeX

        setTileModeXY(mode, mBitmapState.mTileModeY);
public voidsetTileModeXY(Shader.TileMode xmode, Shader.TileMode ymode)
Sets the repeat behavior of this drawable on both axis. By default, the drawable does not repeat its bitmap. Using {@link android.graphics.Shader.TileMode#REPEAT} or {@link android.graphics.Shader.TileMode#MIRROR} the bitmap can be repeated (or tiled) if the bitmap is smaller than this drawable.

param
xmode The X repeat mode for this drawable.
param
ymode The Y repeat mode for this drawable.
see
#setTileModeX(android.graphics.Shader.TileMode)
see
#setTileModeY(android.graphics.Shader.TileMode)

        final BitmapState state = mBitmapState;
        if (state.mTileModeX != xmode || state.mTileModeY != ymode) {
            state.mTileModeX = xmode;
            state.mTileModeY = ymode;
            state.mRebuildShader = true;
            mDstRectAndInsetsDirty = true;
            invalidateSelf();
        }
public final voidsetTileModeY(Shader.TileMode mode)
Sets the repeat behavior of this drawable on the Y axis. By default, the drawable does not repeat its bitmap. Using {@link android.graphics.Shader.TileMode#REPEAT} or {@link android.graphics.Shader.TileMode#MIRROR} the bitmap can be repeated (or tiled) if the bitmap is smaller than this drawable.

param
mode The repeat mode for this drawable.
see
#setTileModeX(android.graphics.Shader.TileMode)
see
#setTileModeXY(android.graphics.Shader.TileMode, android.graphics.Shader.TileMode)
attr
ref android.R.styleable#BitmapDrawable_tileModeY

        setTileModeXY(mBitmapState.mTileModeX, mode);
public voidsetTintList(android.content.res.ColorStateList tint)

        mBitmapState.mTint = tint;
        mTintFilter = updateTintFilter(mTintFilter, tint, mBitmapState.mTintMode);
        invalidateSelf();
public voidsetTintMode(android.graphics.PorterDuff.Mode tintMode)

        mBitmapState.mTintMode = tintMode;
        mTintFilter = updateTintFilter(mTintFilter, mBitmapState.mTint, tintMode);
        invalidateSelf();
public voidsetXfermode(android.graphics.Xfermode xfermode)

hide
Candidate for future API inclusion

        mBitmapState.mPaint.setXfermode(xfermode);
        invalidateSelf();
private voidupdateDstRectAndInsetsIfDirty()

        if (mDstRectAndInsetsDirty) {
            if (mBitmapState.mTileModeX == null && mBitmapState.mTileModeY == null) {
                final Rect bounds = getBounds();
                final int layoutDirection = getLayoutDirection();
                Gravity.apply(mBitmapState.mGravity, mBitmapWidth, mBitmapHeight,
                        bounds, mDstRect, layoutDirection);

                final int left = mDstRect.left - bounds.left;
                final int top = mDstRect.top - bounds.top;
                final int right = bounds.right - mDstRect.right;
                final int bottom = bounds.bottom - mDstRect.bottom;
                mOpticalInsets = Insets.of(left, top, right, bottom);
            } else {
                copyBounds(mDstRect);
                mOpticalInsets = Insets.NONE;
            }
        }
        mDstRectAndInsetsDirty = false;
private voidupdateMirrorMatrix(float dx)

        if (mMirrorMatrix == null) {
            mMirrorMatrix = new Matrix();
        }
        mMirrorMatrix.setTranslate(dx, 0);
        mMirrorMatrix.preScale(-1.0f, 1.0f);
private voidupdateStateFromTypedArray(android.content.res.TypedArray a)
Updates the constant state from the values in the typed array.

        final Resources r = a.getResources();
        final BitmapState state = mBitmapState;

        // Account for any configuration changes.
        state.mChangingConfigurations |= a.getChangingConfigurations();

        // Extract the theme attributes, if any.
        state.mThemeAttrs = a.extractThemeAttrs();

        final int srcResId = a.getResourceId(R.styleable.BitmapDrawable_src, 0);
        if (srcResId != 0) {
            final Bitmap bitmap = BitmapFactory.decodeResource(r, srcResId);
            if (bitmap == null) {
                throw new XmlPullParserException(a.getPositionDescription() +
                        ": <bitmap> requires a valid src attribute");
            }

            state.mBitmap = bitmap;
        }

        state.mTargetDensity = r.getDisplayMetrics().densityDpi;

        final boolean defMipMap = state.mBitmap != null ? state.mBitmap.hasMipMap() : false;
        setMipMap(a.getBoolean(R.styleable.BitmapDrawable_mipMap, defMipMap));

        state.mAutoMirrored = a.getBoolean(
                R.styleable.BitmapDrawable_autoMirrored, state.mAutoMirrored);
        state.mBaseAlpha = a.getFloat(R.styleable.BitmapDrawable_alpha, state.mBaseAlpha);

        final int tintMode = a.getInt(R.styleable.BitmapDrawable_tintMode, -1);
        if (tintMode != -1) {
            state.mTintMode = Drawable.parseTintMode(tintMode, Mode.SRC_IN);
        }

        final ColorStateList tint = a.getColorStateList(R.styleable.BitmapDrawable_tint);
        if (tint != null) {
            state.mTint = tint;
        }

        final Paint paint = mBitmapState.mPaint;
        paint.setAntiAlias(a.getBoolean(
                R.styleable.BitmapDrawable_antialias, paint.isAntiAlias()));
        paint.setFilterBitmap(a.getBoolean(
                R.styleable.BitmapDrawable_filter, paint.isFilterBitmap()));
        paint.setDither(a.getBoolean(R.styleable.BitmapDrawable_dither, paint.isDither()));

        setGravity(a.getInt(R.styleable.BitmapDrawable_gravity, state.mGravity));

        final int tileMode = a.getInt(R.styleable.BitmapDrawable_tileMode, TILE_MODE_UNDEFINED);
        if (tileMode != TILE_MODE_UNDEFINED) {
            final Shader.TileMode mode = parseTileMode(tileMode);
            setTileModeXY(mode, mode);
        }

        final int tileModeX = a.getInt(R.styleable.BitmapDrawable_tileModeX, TILE_MODE_UNDEFINED);
        if (tileModeX != TILE_MODE_UNDEFINED) {
            setTileModeX(parseTileMode(tileModeX));
        }

        final int tileModeY = a.getInt(R.styleable.BitmapDrawable_tileModeY, TILE_MODE_UNDEFINED);
        if (tileModeY != TILE_MODE_UNDEFINED) {
            setTileModeY(parseTileMode(tileModeY));
        }

        // Update local properties.
        initializeWithState(state, r);
private voidverifyState(android.content.res.TypedArray a)
Ensures all required attributes are set.

throws
XmlPullParserException if any required attributes are missing

        final BitmapState state = mBitmapState;
        if (state.mBitmap == null) {
            throw new XmlPullParserException(a.getPositionDescription() +
                    ": <bitmap> requires a valid src attribute");
        }