Double Buffering for Sprites without using Graphics class

I haven't written any Android code but have experience with a lot of Graphics programming in general and in Java have wrote a bit of Swing graphics components.

Bitmap resizedBitmap = Bitmap.createBitmap(bmp, 0, 0, width, height, matrix, true);

You don't want to create a new bitmap every time you want to draw something on the screen.

Ideally you only want to create the one bitmap/canvas, and reuse it.

This is some old code I had, which created a Swing component which implemented double buffering.

So "m_VirtScreen" is an invisible bitmap/buffer, that I write too, and only when everything is drawn on this buffer do I draw the entire image to the screen.

So elsewhere I call Graphics2D getVirtualGraphics() to get the buffer. I write to it, and the component draws the buffer automatically on a paint event.

package gravity.view;

import java.awt.Color;
import java.awt.event.ComponentListener; // Resize event listener
import java.awt.event.ComponentEvent; // Resize event info

import javax.swing.JComponent;
import java.awt.Image;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Dimension;


public abstract class JGraphicsPanel extends JComponent implements ComponentListener
{
    private static final long serialVersionUID = 1L;

    protected Dimension   m_ClientRect;
    protected int         m_width, m_height;
    protected Image       m_VirtScreen   = null;
    protected Graphics2D  m_VirtGraphics = null;

    protected int m_MidX = 0;
    protected int m_MidY = 0;

    public JGraphicsPanel ( )
    {
        super();
        initialise();
    }

    public JGraphicsPanel ( int initHeight, int initWidth )
    {
        super();
        setSize(initHeight, initWidth);
        initialise();
    }


 
    private void initialise()
    {
        this.setAutoscrolls(false);
        this.setLayout(null);
        this.setToolTipText("");
        this.setMinimumSize(new Dimension(50, 50));
        this.setDoubleBuffered(false);
        this.setBackground(Color.BLACK);
        this.setOpaque(true);
        
        m_ClientRect = getSize();
        m_width = m_ClientRect.width;
        m_height = m_ClientRect.height;

        try
        {
            m_VirtScreen = createImage(m_width, m_height);
            m_VirtGraphics = (Graphics2D)m_VirtScreen.getGraphics();
        }
        catch (Exception e)
        {
            // problem creating off-screen memory image of the panel
            m_VirtScreen = null;
            m_VirtGraphics = null;
        }

        addComponentListener(this); // resize our memory image with the panel
    }

    public abstract void onResize();

    public void componentResized(ComponentEvent resizeEvent)
    {
        m_ClientRect = getSize();

        // avoid attempts to resize to the current size
        if ((m_width != m_ClientRect.width) || (m_height != m_ClientRect.height))
        {
            m_width = m_ClientRect.width;
            m_height = m_ClientRect.height;

            try
            {
                if (m_VirtScreen != null)
                    m_VirtScreen.flush(); // free allocated memory

                m_VirtScreen = createImage(m_width, m_height);
                m_VirtGraphics = (Graphics2D)m_VirtScreen.getGraphics();
            }
            catch (Exception e)
            {
                m_VirtScreen = null;
                m_VirtGraphics = null;
            }
        }
        
        m_MidX = m_width >> 1;
        m_MidY = m_height >> 1;
        
        onResize();
    }


    public abstract void onHide();

    public void componentHidden(ComponentEvent e)
    {
        onHide();
    }

    
    public abstract void onMove();

    public void componentMoved(ComponentEvent e)
    {
        onMove();
    }

    
    public abstract void onShow();

    public void componentShown(ComponentEvent e)
    {
        onShow();
    }


    public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height)
    {
        return (true);
    }

    public Graphics2D getVirtualGraphics()
    {
        if (m_VirtGraphics != null)
            return (m_VirtGraphics);
        else
            return ((Graphics2D)getGraphics());
    }
    
    public void paint(Graphics g)
    {
        g.drawImage(m_VirtScreen, 0, 0, this);
    }

}