Meine Anforderung besteht darin, ein mit der Kamera aufgenommenes Bild auf den Server hochzuladen, es sollte jedoch weniger als 500 KB groß sein. Falls es größer als 500 KB ist, muss es auf eine Größe von weniger als 500 KB reduziert werden (aber etwas näher dran)

Dafür verwende ich den folgenden Code -

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        try {
            super.onActivityResult(requestCode, resultCode, data);
            if (resultCode == getActivity().RESULT_OK) {

                    if (requestCode == REQUEST_CODE_CAMERA) {

                        try {

                            photo = MediaStore.Images.Media.getBitmap(
                                    ctx.getContentResolver(), capturedImageUri);
                            String selectedImagePath = getRealPathFromURI(capturedImageUri);

                            img_file = new File(selectedImagePath);

                            Log.d("img_file_size", "file size in KBs (initially): " + (img_file.length()/1000));

                            if(CommonUtilities.isImageFileSizeGreaterThan500KB(img_file)) {
                                photo = CommonUtilities.getResizedBitmapLessThan500KB(photo, 500);
                            }
                            photo = CommonUtilities.getCorrectBitmap(photo, selectedImagePath);


//  // CALL THIS METHOD TO GET THE URI FROM THE BITMAP

                            img_file = new File(ctx.getCacheDir(), "image.jpg");
                            img_file.createNewFile();

//Convert bitmap to byte array
                            ByteArrayOutputStream bytes = new ByteArrayOutputStream();
                            photo.compress(Bitmap.CompressFormat.JPEG, 100, bytes);

//write the bytes in file
                            FileOutputStream fo = new FileOutputStream(img_file);
                            fo.write(bytes.toByteArray());

// remember close de FileOutput
                            fo.close();
                            Log.d("img_file_size", "file size in KBs after image manipulations: " + (img_file.length()/1000));


                        } catch (Exception e) {
                            Logs.setLogException(class_name, "onActivityResult(), when captured from camera", e);
                        }


                    } 

            }
        } catch (Exception e) {
            Logs.setLogException(class_name, "onActivityResult()", e);
        } catch (OutOfMemoryError e) {
            Logs.setLogError(class_name, "onActivityResult()", e);

        }
    }

Un

public static Bitmap getResizedBitmapLessThan500KB(Bitmap image, int maxSize) {
        int width = image.getWidth();
        int height = image.getHeight();



        float bitmapRatio = (float)width / (float) height;
        if (bitmapRatio > 0) {
            width = maxSize;
            height = (int) (width / bitmapRatio);
        } else {
            height = maxSize;
            width = (int) (height * bitmapRatio);
        }
        Bitmap reduced_bitmap = Bitmap.createScaledBitmap(image, width, height, true);
        if(sizeOf(reduced_bitmap) > (500 * 1000)) {
            return getResizedBitmap(reduced_bitmap, maxSize);
        } else {
            return reduced_bitmap;
        }
    }

Um das Bild bei Bedarf zu drehen.

public static Bitmap getCorrectBitmap(Bitmap bitmap, String filePath) {
        ExifInterface ei;
        Bitmap rotatedBitmap = bitmap;
        try {
            ei = new ExifInterface(filePath);

            int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            Matrix matrix = new Matrix();
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    matrix.postRotate(90);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    matrix.postRotate(180);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    matrix.postRotate(270);
                    break;
            }

            rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return rotatedBitmap;
    }

Hier ist die Ausgabe der Bilddateigröße anfangs und nach allen Vorgängen zum Verringern der Dateigröße.

img_file_size ﹕ Dateigröße in KB (anfangs): 3294

img_file_size ﹕ Dateigröße in KB nach Bildmanipulationen: 235

Siehe den obigen Unterschied (in der Ausgabe). Die anfängliche Dateigröße ohne diese Vorgänge sowie nach diesen Komprimierungs- und anderen Vorgängen. Ich brauche diese Größe, um etwas näher an 500 kb zu sein.

Der obige Code funktioniert für mich recht gut, da er die Größe der Bilddatei auf weniger als 500 KB reduziert.

Aber im Folgenden sind die Probleme mit dem obigen Code aufgeführt -

Dieser Code reduziert die Dateigröße, auch wenn sie weniger als 500 KB beträgt

Bei mehr als 500 KB verringert sich die Dateigröße von 500 KB, obwohl ich sie etwas näher benötige.

Ich muss über 2 Probleme loswerden. Müssen Sie also wissen, was ich im obigen Code ändern soll.

Also möchte ich auch die EXIF-Ausrichtung (gedrehte Bilder) korrigieren, zusammen mit meiner oben genannten Anforderung.