FileDocCategorySizeDatePackage
NinePatch_Delegate.javaAPI DocAndroid 5.1 API9447Thu Mar 12 22:22:44 GMT 2015android.graphics

NinePatch_Delegate

public final class NinePatch_Delegate extends Object
Delegate implementing the native methods of android.graphics.NinePatch Through the layoutlib_create tool, the original native methods of NinePatch have been replaced by calls to methods of the same name in this delegate class. Because it's a stateless class to start with, there's no need to keep a {@link DelegateManager} around to map int to instance of the delegate.

Fields Summary
private static final com.android.layoutlib.bridge.impl.DelegateManager
sManager
private static final Map
sChunkCache
Cache map for {@link NinePatchChunk}. When the chunks are created they are serialized into a byte[], and both are put in the cache, using a {@link SoftReference} for the chunk. The default Java classes for {@link NinePatch} and {@link NinePatchDrawable} only reference to the byte[] data, and provide this for drawing. Using the cache map allows us to not have to deserialize the byte[] back into a {@link NinePatchChunk} every time a rendering is done.
private byte[]
chunk
Constructors Summary
Methods Summary
private static voiddraw(long canvas_instance, int left, int top, int right, int bottom, long bitmap_instance, long chunk, long paint_instance_or_null, int destDensity, int srcDensity)

        // get the delegate from the native int.
        final Bitmap_Delegate bitmap_delegate = Bitmap_Delegate.getDelegate(bitmap_instance);
        if (bitmap_delegate == null) {
            return;
        }

        byte[] c = null;
        NinePatch_Delegate delegate = sManager.getDelegate(chunk);
        if (delegate != null) {
            c = delegate.chunk;
        }
        if (c == null) {
            // not a 9-patch?
            BufferedImage image = bitmap_delegate.getImage();
            Canvas_Delegate.native_drawBitmap(null, canvas_instance, bitmap_instance,
                    0f, 0f, (float)image.getWidth(), (float)image.getHeight(),
                    (float)left, (float)top, (float)right, (float)bottom,
                    paint_instance_or_null, destDensity, srcDensity);
            return;
        }

        final NinePatchChunk chunkObject = getChunk(c);
        assert chunkObject != null;
        if (chunkObject == null) {
            return;
        }

        Canvas_Delegate canvas_delegate = Canvas_Delegate.getDelegate(canvas_instance);
        if (canvas_delegate == null) {
            return;
        }

        // this one can be null
        Paint_Delegate paint_delegate = Paint_Delegate.getDelegate(paint_instance_or_null);

        canvas_delegate.getSnapshot().draw(new GcSnapshot.Drawable() {
                @Override
                public void draw(Graphics2D graphics, Paint_Delegate paint) {
                    chunkObject.draw(bitmap_delegate.getImage(), graphics,
                            left, top, right - left, bottom - top, destDensity, srcDensity);
                }
            }, paint_delegate, true /*compositeOnly*/, false /*forceSrcMode*/);

     
public static com.android.ninepatch.NinePatchChunkgetChunk(byte[] array)
Returns a {@link NinePatchChunk} object for the given serialized representation. If the chunk is present in the cache then the object from the cache is returned, otherwise the array is deserialized into a {@link NinePatchChunk} object.

param
array the serialized representation of the chunk.
return
the NinePatchChunk or null if deserialization failed.

        SoftReference<NinePatchChunk> chunkRef = sChunkCache.get(array);
        NinePatchChunk chunk = chunkRef.get();
        if (chunk == null) {
            ByteArrayInputStream bais = new ByteArrayInputStream(array);
            ObjectInputStream ois = null;
            try {
                ois = new ObjectInputStream(bais);
                chunk = (NinePatchChunk) ois.readObject();

                // put back the chunk in the cache
                if (chunk != null) {
                    sChunkCache.put(array, new SoftReference<NinePatchChunk>(chunk));
                }
            } catch (IOException e) {
                Bridge.getLog().error(LayoutLog.TAG_BROKEN,
                        "Failed to deserialize NinePatchChunk content.", e, null /*data*/);
                return null;
            } catch (ClassNotFoundException e) {
                Bridge.getLog().error(LayoutLog.TAG_BROKEN,
                        "Failed to deserialize NinePatchChunk class.", e, null /*data*/);
                return null;
            } finally {
                if (ois != null) {
                    try {
                        ois.close();
                    } catch (IOException e) {
                    }
                }
            }
        }

        return chunk;
    
static booleanisNinePatchChunk(byte[] chunk)

        NinePatchChunk chunkObject = getChunk(chunk);
        if (chunkObject != null) {
            return true;
        }

        return false;
    
static voidnativeDraw(long canvas_instance, RectF loc, long bitmap_instance, long chunk, long paint_instance_or_null, int destDensity, int srcDensity)

        draw(canvas_instance,
                (int) loc.left, (int) loc.top, (int) loc.right, (int) loc.bottom,
                bitmap_instance, chunk, paint_instance_or_null,
                destDensity, srcDensity);
    
static voidnativeDraw(long canvas_instance, Rect loc, long bitmap_instance, long chunk, long paint_instance_or_null, int destDensity, int srcDensity)

        draw(canvas_instance,
                loc.left, loc.top, loc.right, loc.bottom,
                bitmap_instance, chunk, paint_instance_or_null,
                destDensity, srcDensity);
    
static voidnativeFinalize(long chunk)

        sManager.removeJavaReferenceFor(chunk);
    
static longnativeGetTransparentRegion(long bitmap, long chunk, Rect location)

        return 0;
    
public static byte[]serialize(com.android.ninepatch.NinePatchChunk chunk)
Serializes the given chunk.

return
the serialized data for the chunk.



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

                    
         
        // serialize the chunk to get a byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(baos);
            oos.writeObject(chunk);
        } catch (IOException e) {
            Bridge.getLog().error(null, "Failed to serialize NinePatchChunk.", e, null /*data*/);
            return null;
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                }
            }
        }

        // get the array and add it to the cache
        byte[] array = baos.toByteArray();
        sChunkCache.put(array, new SoftReference<NinePatchChunk>(chunk));
        return array;
    
static longvalidateNinePatchChunk(long bitmap, byte[] chunk)

        // the default JNI implementation only checks that the byte[] has the same
        // size as the C struct it represent. Since we cannot do the same check (serialization
        // will return different size depending on content), we do nothing.
        NinePatch_Delegate newDelegate = new NinePatch_Delegate();
        newDelegate.chunk = chunk;
        return sManager.addNewDelegate(newDelegate);