FileDocCategorySizeDatePackage
Bitmap_Delegate.javaAPI DocAndroid 5.1 API22852Thu Mar 12 22:22:44 GMT 2015android.graphics

Bitmap_Delegate

public final class Bitmap_Delegate extends Object
Delegate implementing the native methods of android.graphics.Bitmap Through the layoutlib_create tool, the original native methods of Bitmap have been replaced by calls to methods of the same name in this delegate class. This class behaves like the original native implementation, but in Java, keeping previously native data into its own objects and mapping them to int that are sent back and forth between it and the original Bitmap class.
see
DelegateManager

Fields Summary
private static final com.android.layoutlib.bridge.impl.DelegateManager
sManager
private final android.graphics.Bitmap.Config
mConfig
private BufferedImage
mImage
private boolean
mHasAlpha
private boolean
mHasMipMap
private boolean
mIsPremultiplied
private int
mGenerationId
Constructors Summary
private Bitmap_Delegate(BufferedImage image, android.graphics.Bitmap.Config config)

        mImage = image;
        mConfig = config;
Methods Summary
public voidchange()
Update the generationId.

see
Bitmap#getGenerationId()

        mGenerationId++;
public static BitmapcreateBitmap(java.io.File input, boolean isMutable, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given file content.

param
input the file from which to read the bitmap content
param
isMutable whether the bitmap is mutable
param
density the density associated with the bitmap
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        return createBitmap(input, getPremultipliedBitmapCreateFlags(isMutable), density);
public static BitmapcreateBitmap(java.io.File input, java.util.Set createFlags, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given file content.

param
input the file from which to read the bitmap content
param
density the density associated with the bitmap
see
Bitmap#isPremultiplied()
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        // create a delegate with the content of the file.
        Bitmap_Delegate delegate = new Bitmap_Delegate(ImageIO.read(input), Config.ARGB_8888);

        return createBitmap(delegate, createFlags, density.getDpiValue());
private static BitmapcreateBitmap(android.graphics.Bitmap_Delegate delegate, java.util.Set createFlags, int density)

        // get its native_int
        long nativeInt = sManager.addNewDelegate(delegate);

        int width = delegate.mImage.getWidth();
        int height = delegate.mImage.getHeight();
        boolean isMutable = createFlags.contains(BitmapCreateFlags.MUTABLE);
        boolean isPremultiplied = createFlags.contains(BitmapCreateFlags.PREMULTIPLIED);

        // and create/return a new Bitmap with it
        return new Bitmap(nativeInt, null /* buffer */, width, height, density, isMutable,
                          isPremultiplied, null /*ninePatchChunk*/, null /* layoutBounds */);
public static BitmapcreateBitmap(java.io.InputStream input, boolean isMutable, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given stream content.

param
input the stream from which to read the bitmap content
param
isMutable whether the bitmap is mutable
param
density the density associated with the bitmap
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        return createBitmap(input, getPremultipliedBitmapCreateFlags(isMutable), density);
public static BitmapcreateBitmap(java.io.InputStream input, java.util.Set createFlags, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given stream content.

param
input the stream from which to read the bitmap content
param
density the density associated with the bitmap
see
Bitmap#isPremultiplied()
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        // create a delegate with the content of the stream.
        Bitmap_Delegate delegate = new Bitmap_Delegate(ImageIO.read(input), Config.ARGB_8888);

        return createBitmap(delegate, createFlags, density.getDpiValue());
public static BitmapcreateBitmap(java.awt.image.BufferedImage image, boolean isMutable, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given {@link BufferedImage}

param
image the bitmap content
param
isMutable whether the bitmap is mutable
param
density the density associated with the bitmap
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        return createBitmap(image, getPremultipliedBitmapCreateFlags(isMutable), density);
public static BitmapcreateBitmap(java.awt.image.BufferedImage image, java.util.Set createFlags, com.android.resources.Density density)
Creates and returns a {@link Bitmap} initialized with the given {@link BufferedImage}

param
image the bitmap content
param
density the density associated with the bitmap
see
Bitmap#isPremultiplied()
see
Bitmap#isMutable()
see
Bitmap#getDensity()

        // create a delegate with the given image.
        Bitmap_Delegate delegate = new Bitmap_Delegate(image, Config.ARGB_8888);

        return createBitmap(delegate, createFlags, density.getDpiValue());
static java.awt.image.BufferedImagecreateCopy(java.awt.image.BufferedImage image, int imageType, int alpha)
Creates and returns a copy of a given BufferedImage.

if alpha is different than 255, then it is applied to the alpha channel of each pixel.

param
image the image to copy
param
imageType the type of the new image
param
alpha an optional alpha modifier
return
a new BufferedImage

        int w = image.getWidth();
        int h = image.getHeight();

        BufferedImage result = new BufferedImage(w, h, imageType);

        int[] argb = new int[w * h];
        image.getRGB(0, 0, image.getWidth(), image.getHeight(), argb, 0, image.getWidth());

        if (alpha != 255) {
            final int length = argb.length;
            for (int i = 0 ; i < length; i++) {
                int a = (argb[i] >>> 24 * alpha) / 255;
                argb[i] = (a << 24) | (argb[i] & 0x00FFFFFF);
            }
        }

        result.setRGB(0, 0, w, h, argb, 0, w);

        return result;
public static intgetBufferedImageType(int nativeBitmapConfig)

        switch (Config.nativeToConfig(nativeBitmapConfig)) {
            case ALPHA_8:
                return BufferedImage.TYPE_INT_ARGB;
            case RGB_565:
                return BufferedImage.TYPE_INT_ARGB;
            case ARGB_4444:
                return BufferedImage.TYPE_INT_ARGB;
            case ARGB_8888:
                return BufferedImage.TYPE_INT_ARGB;
        }

        return BufferedImage.TYPE_INT_ARGB;
public android.graphics.Bitmap.ConfiggetConfig()
Returns the Android bitmap config. Note that this not the config of the underlying Java2D bitmap.

        return mConfig;
public static android.graphics.Bitmap_DelegategetDelegate(Bitmap bitmap)
Returns the native delegate associated to a given {@link Bitmap_Delegate} object.



    // ---- Public Helper methods ----

                    
         
        return sManager.getDelegate(bitmap.mNativeBitmap);
public static android.graphics.Bitmap_DelegategetDelegate(long native_bitmap)
Returns the native delegate associated to a given an int referencing a {@link Bitmap} object.

        return sManager.getDelegate(native_bitmap);
public java.awt.image.BufferedImagegetImage()
Returns the {@link BufferedImage} used by the delegate of the given {@link Bitmap}.

        return mImage;
public static java.awt.image.BufferedImagegetImage(Bitmap bitmap)
Returns the {@link BufferedImage} used by the delegate of the given {@link Bitmap}.

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(bitmap.mNativeBitmap);
        if (delegate == null) {
            return null;
        }

        return delegate.mImage;
private static java.util.SetgetPremultipliedBitmapCreateFlags(boolean isMutable)

        Set<BitmapCreateFlags> createFlags = EnumSet.of(BitmapCreateFlags.PREMULTIPLIED);
        if (isMutable) {
            createFlags.add(BitmapCreateFlags.MUTABLE);
        }
        return createFlags;
public booleanhasAlpha()
Returns the hasAlpha rendering hint

return
true if the bitmap alpha should be used at render time

        return mHasAlpha && mConfig != Config.RGB_565;
public booleanhasMipMap()

        // TODO: check if more checks are required as in hasAlpha.
        return mHasMipMap;
static booleannativeCompress(long nativeBitmap, int format, int quality, java.io.OutputStream stream, byte[] tempStorage)

        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
                "Bitmap.compress() is not supported", null /*data*/);
        return true;
static intnativeConfig(long nativeBitmap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return 0;
        }

        return delegate.mConfig.nativeInt;
static BitmapnativeCopy(long srcBitmap, int nativeConfig, boolean isMutable)

        Bitmap_Delegate srcBmpDelegate = sManager.getDelegate(srcBitmap);
        if (srcBmpDelegate == null) {
            return null;
        }

        BufferedImage srcImage = srcBmpDelegate.getImage();

        int width = srcImage.getWidth();
        int height = srcImage.getHeight();

        int imageType = getBufferedImageType(nativeConfig);

        // create the image
        BufferedImage image = new BufferedImage(width, height, imageType);

        // copy the source image into the image.
        int[] argb = new int[width * height];
        srcImage.getRGB(0, 0, width, height, argb, 0, width);
        image.setRGB(0, 0, width, height, argb, 0, width);

        // create a delegate with the content of the stream.
        Bitmap_Delegate delegate = new Bitmap_Delegate(image, Config.nativeToConfig(nativeConfig));

        return createBitmap(delegate, getPremultipliedBitmapCreateFlags(isMutable),
                Bitmap.getDefaultDensity());
static voidnativeCopyPixelsFromBuffer(long nb, java.nio.Buffer src)

        // FIXME implement native delegate
        Bridge.getLog().fidelityWarning(LayoutLog.TAG_UNSUPPORTED,
                "Bitmap.copyPixelsFromBuffer is not supported.", null, null /*data*/);
static voidnativeCopyPixelsToBuffer(long nativeBitmap, java.nio.Buffer dst)

        // FIXME implement native delegate
        Bridge.getLog().fidelityWarning(LayoutLog.TAG_UNSUPPORTED,
                "Bitmap.copyPixelsToBuffer is not supported.", null, null /*data*/);
static BitmapnativeCreate(int[] colors, int offset, int stride, int width, int height, int nativeConfig, boolean isMutable)

        int imageType = getBufferedImageType(nativeConfig);

        // create the image
        BufferedImage image = new BufferedImage(width, height, imageType);

        if (colors != null) {
            image.setRGB(0, 0, width, height, colors, offset, stride);
        }

        // create a delegate with the content of the stream.
        Bitmap_Delegate delegate = new Bitmap_Delegate(image, Config.nativeToConfig(nativeConfig));

        return createBitmap(delegate, getPremultipliedBitmapCreateFlags(isMutable),
                            Bitmap.getDefaultDensity());
static BitmapnativeCreateFromParcel(android.os.Parcel p)

        // This is only called by Bitmap.CREATOR (Parcelable.Creator<Bitmap>), which is only
        // used during aidl call so really this should not be called.
        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
                "AIDL is not suppored, and therefore Bitmaps cannot be created from parcels.",
                null /*data*/);
        return null;
static voidnativeDestructor(long nativeBitmap)

        sManager.removeJavaReferenceFor(nativeBitmap);
static voidnativeErase(long nativeBitmap, int color)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        BufferedImage image = delegate.mImage;

        Graphics2D g = image.createGraphics();
        try {
            g.setColor(new java.awt.Color(color, true));

            g.fillRect(0, 0, image.getWidth(), image.getHeight());
        } finally {
            g.dispose();
        }
static BitmapnativeExtractAlpha(long nativeBitmap, long nativePaint, int[] offsetXY)

        Bitmap_Delegate bitmap = sManager.getDelegate(nativeBitmap);
        if (bitmap == null) {
            return null;
        }

        // get the paint which can be null if nativePaint is 0.
        Paint_Delegate paint = Paint_Delegate.getDelegate(nativePaint);

        if (paint != null && paint.getMaskFilter() != null) {
            Bridge.getLog().fidelityWarning(LayoutLog.TAG_MASKFILTER,
                    "MaskFilter not supported in Bitmap.extractAlpha",
                    null, null /*data*/);
        }

        int alpha = paint != null ? paint.getAlpha() : 0xFF;
        BufferedImage image = createCopy(bitmap.getImage(), BufferedImage.TYPE_INT_ARGB, alpha);

        // create the delegate. The actual Bitmap config is only an alpha channel
        Bitmap_Delegate delegate = new Bitmap_Delegate(image, Config.ALPHA_8);

        // the density doesn't matter, it's set by the Java method.
        return createBitmap(delegate, EnumSet.of(BitmapCreateFlags.MUTABLE),
                Density.DEFAULT_DENSITY /*density*/);
static intnativeGenerationId(long nativeBitmap)

        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return 0;
        }

        return delegate.mGenerationId;
static intnativeGetPixel(long nativeBitmap, int x, int y)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return 0;
        }

        return delegate.mImage.getRGB(x, y);
static voidnativeGetPixels(long nativeBitmap, int[] pixels, int offset, int stride, int x, int y, int width, int height)

        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.getImage().getRGB(x, y, width, height, pixels, offset, stride);
static booleannativeHasAlpha(long nativeBitmap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return true;
        }

        return delegate.mHasAlpha;
static booleannativeHasMipMap(long nativeBitmap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return true;
        }

        return delegate.mHasMipMap;
static booleannativeIsPremultiplied(long nativeBitmap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        return delegate != null && delegate.mIsPremultiplied;
static voidnativePrepareToDraw(long nativeBitmap)

        // nothing to be done here.
static voidnativeReconfigure(long nativeBitmap, int width, int height, int config, int allocSize, boolean isPremultiplied)

        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
                "Bitmap.reconfigure() is not supported", null /*data*/);
static booleannativeRecycle(long nativeBitmap)

        sManager.removeJavaReferenceFor(nativeBitmap);
        return true;
static intnativeRowBytes(long nativeBitmap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return 0;
        }

        return delegate.mImage.getWidth();
static booleannativeSameAs(long nb0, long nb1)

        Bitmap_Delegate delegate1 = sManager.getDelegate(nb0);
        if (delegate1 == null) {
            return false;
        }

        Bitmap_Delegate delegate2 = sManager.getDelegate(nb1);
        if (delegate2 == null) {
            return false;
        }

        BufferedImage image1 = delegate1.getImage();
        BufferedImage image2 = delegate2.getImage();
        if (delegate1.mConfig != delegate2.mConfig ||
                image1.getWidth() != image2.getWidth() ||
                image1.getHeight() != image2.getHeight()) {
            return false;
        }

        // get the internal data
        int w = image1.getWidth();
        int h = image2.getHeight();
        int[] argb1 = new int[w*h];
        int[] argb2 = new int[w*h];

        image1.getRGB(0, 0, w, h, argb1, 0, w);
        image2.getRGB(0, 0, w, h, argb2, 0, w);

        // compares
        if (delegate1.mConfig == Config.ALPHA_8) {
            // in this case we have to manually compare the alpha channel as the rest is garbage.
            final int length = w*h;
            for (int i = 0 ; i < length ; i++) {
                if ((argb1[i] & 0xFF000000) != (argb2[i] & 0xFF000000)) {
                    return false;
                }
            }
            return true;
        }

        return Arrays.equals(argb1, argb2);
static voidnativeSetHasAlpha(long nativeBitmap, boolean hasAlpha, boolean isPremul)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.mHasAlpha = hasAlpha;
static voidnativeSetHasMipMap(long nativeBitmap, boolean hasMipMap)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.mHasMipMap = hasMipMap;
static voidnativeSetPixel(long nativeBitmap, int x, int y, int color)

        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.getImage().setRGB(x, y, color);
static voidnativeSetPixels(long nativeBitmap, int[] colors, int offset, int stride, int x, int y, int width, int height)

        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.getImage().setRGB(x, y, width, height, colors, offset, stride);
static voidnativeSetPremultiplied(long nativeBitmap, boolean isPremul)

        // get the delegate from the native int.
        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
        if (delegate == null) {
            return;
        }

        delegate.mIsPremultiplied = isPremul;
static booleannativeWriteToParcel(long nativeBitmap, boolean isMutable, int density, android.os.Parcel p)

        // This is only called when sending a bitmap through aidl, so really this should not
        // be called.
        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
                "AIDL is not suppored, and therefore Bitmaps cannot be written to parcels.",
                null /*data*/);
        return false;