Comment stocker l'image dans la base de données SQLite

Utilisez blob pour stocker votre image dans votre base de données sqlite. Voici un exemple sur la façon d'utiliser blob.

La Configuration de la base de données

CREATE TABLE " + DB_TABLE + "("+ 
                   KEY_NAME + " TEXT," + 
                   KEY_IMAGE + " BLOB);";

Insérez dans la Base de données:

public void addEntry( String name, byte[] image) throws SQLiteException{
    ContentValues cv = new  ContentValues();
    cv.put(KEY_NAME,    name);
    cv.put(KEY_IMAGE,   image);
    database.insert( DB_TABLE, null, cv );
}

La Récupération de données:

 byte[] image = cursor.getBlob(1);

Note:

1. avant d'insérer dans la base de données, vous devez d'abord convertir votre image Bitmap en tableau d'octets, puis l'appliquer à l'aide de la requête de base de données.
2. lors de la récupération de la base de données, vous certainement avoir un tableau d'octets d'image, ce que vous devez faire est de convertir le tableau d'octets en image d'origine. Donc, vous devez utiliser BitmapFactory pour décoder.

Voici une classe D'utilité qui, j'espère, pourrait vous aider:

public class DbBitmapUtility {

    // convert from bitmap to byte array
    public static byte[] getBytes(Bitmap bitmap) {
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(CompressFormat.PNG, 0, stream);
        return stream.toByteArray();
    }

    // convert from byte array to bitmap
    public static Bitmap getImage(byte[] image) {
        return BitmapFactory.decodeByteArray(image, 0, image.length);
    }
}

Je crois que la meilleure façon de stocker une image dans une base de données SQLLite est d'utiliser L'algorithme de base 64. qui convertit une image en texte brut et inversement. Vous pouvez télécharger l'exemple complet du projet Android à: http://developersfound.com/Base64FromStream.zip . ce programme ne stocke pas l'image, mais il convertit l'image de l'image en texte et inversement.

Voici la classe:

package com.example.TestProject;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Base64;
import android.util.Log;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.nio.channels.FileChannel;

public class Base64CODEC {
    private int IO_BUFFER_SIZE = 64;
    //private int IO_BUFFER_SIZE = 8192;
    private URL urlObject = null;
    private URLConnection myConn = null;
    ByteArrayOutputStream os = null;

    public void Base64CODEC() {}

    public Bitmap Base64ImageFromURL(String url) {
        Bitmap bitmap = null;
        InputStream in = null;
        BufferedOutputStream out = null;

        try {
            urlObject = new URL(url);
            myConn = urlObject.openConnection();
            in = myConn.getInputStream();

            final ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
            out = new BufferedOutputStream(dataStream, IO_BUFFER_SIZE);

            copyCompletely(in, out);

            final byte[] data = dataStream.toByteArray();
            BitmapFactory.Options options = new BitmapFactory.Options();

            bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
        } catch (IOException e) {
            Log.e("TAG", "Could not load Bitmap from: " + url);
        } finally {
            //closeStream(in);
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
            //closeStream(out);
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
            }
        }

        return bitmap;
    }

    private void copyCompletely(InputStream input, OutputStream output) throws IOException {
        // if both are file streams, use channel IO
        if ((output instanceof FileOutputStream) && (input instanceof FileInputStream)) {
            try {
                FileChannel target = ((FileOutputStream) output).getChannel();
                FileChannel source = ((FileInputStream) input).getChannel();

                source.transferTo(0, Integer.MAX_VALUE, target);

                source.close();
                target.close();

                return;
            } catch (Exception e) { /* failover to byte stream version */
            }
        }

        byte[] buf = new byte[8192];
        while (true) {
            int length = input.read(buf);
            if (length < 0)
                break;
            output.write(buf, 0, length);
        }

        try {
            input.close();
        } catch (IOException ignore) {
        }
        try {
            output.close();
        } catch (IOException ignore) {}
    }

    public String convertToBase64(Bitmap bitmap) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG,100,os);
        byte[] byteArray = os.toByteArray();
        return Base64.encodeToString(byteArray, 0);
    }

    public Bitmap convertToBitmap(String base64String) {
        byte[] decodedString = Base64.decode(base64String, Base64.DEFAULT);
        Bitmap bitmapResult = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
        return bitmapResult;
    }

}

Et voici l'activité principale qui utilise la classe:

package com.example.TestProject;

import android.app.Activity;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.ImageView;

public class MainActivity extends Activity implements Runnable {

    private Thread thread = null;
    private Bitmap bitmap = null;
    private Base64CODEC base64CODEC = null;
    private ImageView imgViewSource = null;
    private ImageView imgViewDestination = null;
    private boolean isSourceImageVisible = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    public void CmdLoadImage_Click(View view) {
        try {
            if(isSourceImageVisible == true) {
                imgViewSource.setImageBitmap(null);
                imgViewDestination.setImageBitmap(null);
                isSourceImageVisible = false;
            }
            else {
                base64CODEC = new Base64CODEC();
                thread = new Thread(this);
                thread.start();
            }
        }
        catch (NullPointerException e) {}

    }

    public void CmdEncodeImage_Click(View view) {
        Base64CODEC base64CODEC = new Base64CODEC();
        try {
            String base64String = base64CODEC.convertToBase64(bitmap);
            imgViewDestination = (ImageView) findViewById(R.id.imgViewDestination);
            Bitmap imgViewDestinationBitmap = base64CODEC.convertToBitmap(base64String);
            imgViewDestination.setImageBitmap(imgViewDestinationBitmap);
        }
        catch (NullPointerException e) {
            //
        }
    }

    @Override
    public void run() {
        bitmap = base64CODEC.Base64ImageFromURL("http://developersfound.com/me.png");
        handler.sendEmptyMessage(0);
    }

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            imgViewSource = (ImageView) findViewById(R.id.imgViewSource);
            imgViewSource.setImageBitmap(bitmap);
            isSourceImageVisible = true;
            thread = null;
        }
    };

}

Pour stocker une image dans la base de données sqlite, vous devez stocker cette image dans un tableau d'octets au lieu d'une chaîne. Convertissez cette image en tableau d'octets et stockez cet octet [] en DB. Lors de la récupération de cette image, vous obtiendrez byte [] convertir cet octet [] en bitmap par lequel vous obtiendrez l'image originale.

J'ai deux choses que j'ai besoin de noter. Comment stocker l'image de la galerie et comment stocker l'image de l'uri par exemple (www.example.com/myimage.png)

Comment stocker l'image de la galerie

Les Images sont extraites de la galerie informer du type de données Uri. Pour stocker des images dans la base de données Android SQLite, vous devez convertir l'uri de l'image en bitmap puis en caractères binaires, c'est-à-dire la séquence bytes []. Définissez ensuite le type de données de la colonne de la table comme type de données BLOB. Après avoir récupéré les images de DB, convertissez le type de données byte[] en bitmap afin de le définir sur imageview.

Comment stocker l'image de l'uri.

Notez que vous pouvez stocker des images dans la base de données en tant que chaîne d'uri, mais uniquement l'uri de l'image d'un site web. Convertissez l'uri en chaîne et insérez-le dans votre base de données. Récupérez votre uri d'image en tant que chaîne et convertissez-le en type de données uri afin de le définir sur imageview.

Vous pouvez essayer ce post pour le programme travaillé et code source comment stocker des images dans la base de données Sqlite et afficher dans listview