#ifndef sw_FrameBufferAndroid_hpp
#define sw_FrameBufferAndroid_hpp

#include "Main/FrameBuffer.hpp"
#include "Common/Debug.hpp"

#include <hardware/gralloc.h>
#include <system/window.h>

namespace sw
{
    class FrameBufferAndroid : public FrameBuffer
    {
    public:
        FrameBufferAndroid(ANativeWindow* window, int width, int height);

        ~FrameBufferAndroid();

        void flip(void *source, Format sourceFormat, size_t sourceStride) override {blit(source, 0, 0, sourceFormat, sourceStride);};
		void blit(void *source, const Rect *sourceRect, const Rect *destRect, Format sourceFormat, size_t sourceStride) override;

		void *lock() override;
		void unlock() override;

        bool setSwapRectangle(int l, int t, int w, int h);

    private:
        ANativeWindow* nativeWindow;
        ANativeWindowBuffer* buffer;
        gralloc_module_t const* gralloc;
    };
}

#endif   // sw_FrameBufferAndroid
