Converters.java

package external.GifImageViewEx.net.frakbot.imageviewex;

import android.content.Context;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import com.aiyou.utils.logcat.Logcat;

/**
 * Converters class, it's abstract and all of its methods are static.
 * 
 * @author Francesco Pontillo, Sebastiano Poggi
 */
public abstract class Converters {
    private static final String TAG = Converters.class.getSimpleName();

    /**
     * Converts a byte array into a BitmapDrawable, using the provided options.
     * 
     * @param image The byte array representing the image.
     * @param opts The decoding options to use, or null if you'd like to use
     *            predefined options (scaling will be not active).
     * @param context The Context for getting the Resources.
     * @return The initialized BitmapDrawable.
     */
    public static BitmapDrawable byteArrayToDrawable(byte[] image,
            Options opts, Context context) {
        if (opts == null) {
            Logcat.v(TAG, "byteArrayToDrawable:opts is null, initializing without scaling");
            opts = new Options();
            opts.inScaled = false;
        }
        Bitmap bmp = BitmapFactory
                .decodeByteArray(image, 0, image.length, opts);
        // bmp.setDensity(DisplayMetrics.DENSITY_HIGH);
        return new BitmapDrawable(context.getResources(), bmp);
    }

    /**
     * Converts a byte array into a Bitmap, using the provided options.
     * 
     * @param image The byte array representing the image.
     * @param opts The decoding options to use, or null if you'd like to use
     *            predefined options (scaling will be not active).
     * @return The initialized BitmapDrawable.
     */
    public static Bitmap byteArrayToBitmap(byte[] image, Options opts) {
        if (opts == null) {
            Logcat.v(TAG, "byteArrayToBitmap:opts is null, initializing without scaling");
            opts = new Options();
            opts.inScaled = false;
        }
        return BitmapFactory.decodeByteArray(image, 0, image.length, opts);
    }

    /**
     * Covnerts a Bitmap into a byte array.
     * 
     * @param image The Bitmap to convert.
     * @return The byte array representing the Bitmap (compressed in PNG).
     */
    public static byte[] bitmapToByteArray(Bitmap image) {
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.PNG, 100, stream);
        return stream.toByteArray();
    }

    /**
     * Converts a Drawable into a byte array.
     * 
     * @param image The Drawable to convertLa Drawable da convertire.
     * @return The byte array representing the Drawable (compressed in PNG).
     */
    public static byte[] drawableToByteArray(Drawable image) {
        Bitmap bitmap = ((BitmapDrawable) image).getBitmap();
        return bitmapToByteArray(bitmap);
    }

    /**
     * Gets an asset from a provided AssetManager and its name in the directory
     * and returns a byte array representing the object content.
     * 
     * @param assetManager An {@link AssetManager}.
     * @param asset String of the file name.
     * @return byte[] representing the object content.
     */
    public static byte[] assetToByteArray(AssetManager assetManager,
            String asset) {
        byte[] image = null;
        int b;
        InputStream is = null;
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();

        try {
            is = assetManager.open(asset);
            while ((b = is.read()) != -1) {
                outStream.write(b);
            }
            image = outStream.toByteArray();
        } catch (IOException e) {
            Logcat.v(TAG, "assetToByteArray:Error while reading asset to byte array: " + asset);
            image = null;
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException ignored) {
                }
            }

            try {
                outStream.close();
            } catch (IOException ignored) {
            }
        }

        return image;
    }

    /**
     * Converts an {@link InputStream} into a byte array.
     * 
     * @param is The {@link InputStream} to convert.
     * @param size The size of the {@link InputStream}.
     * @return The converted byte array.
     */
    public static byte[] inputStreamToByteArray(InputStream is, int size) {
        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
        byte[] buffer = new byte[size];

        int len = 0;
        try {
            while ((len = is.read(buffer)) != -1) {
                byteBuffer.write(buffer, 0, len);
            }
        } catch (IOException e) {

        }

        buffer = byteBuffer.toByteArray();
        return buffer;
    }
}