Android：如何将字节数组转为Blob存入SQLite（相机图片存储）

Hey there! Let's tackle your two Android development questions step by step—storing camera photos in SQLite as Blobs and fixing that getBytes() method issue.

1. Full Workflow: Capture → Bitmap to Bytes → Store in SQLite Blob #

Here's the end-to-end process to get your camera photos into a SQLite Blob field:

• Capture the photo & get Bitmap: You already have this part covered in your onActivityResult callback, where you extract the thumbnail Bitmap from the intent extras.
• Convert Bitmap to byte array: This is where your getBytes() method needs fixing—we'll cover that next.
• Insert into SQLite: Android's SQLite API handles byte arrays directly for Blob fields, so no extra conversion to a Blob object is needed.

2. Fixing the getBytes(imageBitmap) Method #

The core issue here is likely an incomplete or incorrect implementation of the getBytes() function. Below are two reliable ways to convert a Bitmap to a byte array:

Option 1: Compress Bitmap (Recommended) #

This method lets you control image quality and keeps the byte array size manageable. Use PNG for lossless compression or JPEG for smaller file sizes:

private byte[] getBytes(Bitmap bitmap) {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    // Use PNG for lossless quality, or JPEG with a quality value (0-100)
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
    return outputStream.toByteArray();
}

For JPEG compression (e.g., 80% quality):

bitmap.compress(Bitmap.CompressFormat.JPEG, 80, outputStream);

Option 2: Raw Pixel Data (Not Recommended for Large Images) #

This reads the Bitmap's raw pixel data, resulting in a much larger byte array (size = width × height × 4 for ARGB_8888 format). Only use this for tiny images:

private byte[] getBytes(Bitmap bitmap) {
    int byteCount = bitmap.getByteCount();
    ByteBuffer buffer = ByteBuffer.allocate(byteCount);
    bitmap.copyPixelsToBuffer(buffer);
    return buffer.array();
}

3. Full SQLite Implementation Example #

Step 1: Create a Database Helper with a Blob Field #

First, set up your database table to store the image data:

public class PhotoDbHelper extends SQLiteOpenHelper {
    private static final String DB_NAME = "PhotoStorage.db";
    private static final int DB_VERSION = 1;

    public PhotoDbHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        String createTableQuery = "CREATE TABLE captured_photos (" +
                "id INTEGER PRIMARY KEY AUTOINCREMENT," +
                "image_data BLOB)";
        db.execSQL(createTableQuery);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS captured_photos");
        onCreate(db);
    }

    // Insert photo byte array into the database
    public long insertPhoto(byte[] photoBytes) {
        SQLiteDatabase db = getWritableDatabase();
        ContentValues values = new ContentValues();
        values.put("image_data", photoBytes); // Directly pass byte array for Blob
        long photoId = db.insert("captured_photos", null, values);
        db.close();
        return photoId;
    }

    // Optional: Retrieve photo from database
    public byte[] getPhotoById(long photoId) {
        SQLiteDatabase db = getReadableDatabase();
        Cursor cursor = db.query("captured_photos", 
                new String[]{"image_data"}, 
                "id=?", 
                new String[]{String.valueOf(photoId)}, 
                null, null, null);
        
        byte[] photoBytes = null;
        if (cursor.moveToFirst()) {
            photoBytes = cursor.getBlob(cursor.getColumnIndexOrThrow("image_data"));
        }
        cursor.close();
        db.close();
        return photoBytes;
    }
}

Step 2: Update Your Camera Callback to Store the Photo #

Integrate the database code into your existing onActivityResult logic:

private static final int REQUEST_IMAGE_CAPTURE = 1;

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    
    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
        Bundle extras = data.getExtras();
        Bitmap imageBitmap = (Bitmap) extras.get("data");
        
        // Convert Bitmap to byte array using our fixed method
        byte[] photoBytes = getBytes(imageBitmap);
        
        // Store in SQLite
        PhotoDbHelper dbHelper = new PhotoDbHelper(this);
        long storedPhotoId = dbHelper.insertPhoto(photoBytes);
        
        // Optional: Verify by retrieving and displaying the photo
        byte[] retrievedBytes = dbHelper.getPhotoById(storedPhotoId);
        Bitmap retrievedBitmap = BitmapFactory.decodeByteArray(retrievedBytes, 0, retrievedBytes.length);
        // imageView.setImageBitmap(retrievedBitmap);
    }
}

// Our fixed getBytes method
private byte[] getBytes(Bitmap bitmap) {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
    return outputStream.toByteArray();
}

Key Notes #

• Thumbnail vs. Full-Size Photo: extras.get("data") only returns a low-resolution thumbnail. To store the full-size photo, you'll need to capture the image to a file path instead of using the default intent extras.
• Blob Size Limits: SQLite supports large Blobs, but storing big images directly in the database can slow down performance. For large photos, consider storing the file path in SQLite instead, and saving the actual image file to internal/external storage.
• Memory Management: Always recycle Bitmaps when you're done with them (especially on older Android versions) to avoid memory leaks: imageBitmap.recycle();

内容的提问来源于stack exchange，提问作者Music Backup