आउटऑफ मेमरी एरर या डाउनस्कलिंग के बिना एंड्रॉइड में एक छवि को घुमाएं

Question

असल में मैं एंड्रॉइड ऐप में बिटमैप (एक छवि से) घुमाने की कोशिश कर रहा हूं। कारण यह है कि मैं ऐसा करना चाहता हूं कि कैमरे से (एक इरादे से) एक तस्वीर क्षैतिज रूप से प्रदर्शित होती है, भले ही यह लंबवत पर कब्जा कर लिया गया हो, और अभिविन्यास छवि पर मेटाडेटा के रूप में रखा जाता है। गलत होने पर मुझे सही करें। समस्या यह है कि, जब लोड किया जाता है तो छवि लोड होने पर बहुत मेमोरी लेती है, अगर एक उचित कैमरे के साथ फोन पर लिया जाता है, और मुझे आउटऑफमेमरी एरर प्राप्त करने के जोखिम के बिना घूमने और सहेजने का कोई तरीका नहीं मिला है । नीचे दिए गए कोड है, जहां मैं:

1. छवि में लोड
2. चेक अगर यह एक imageView
3. में
4. भार प्रदर्शन के लिए एक छोटा-डाउन संस्करण घुमाया जा करने की जरूरत है छोटे छवि यदि आवश्यक हो तो घुमाता
5. एक अलग धागे में; लोड, घुमाएं और छवि को सहेजें, इसलिए भविष्य में

एप्लिकेशन के लिए संकल्प में रखने के लिए एप्लिकेशन के लिए महत्वपूर्ण है, लेकिन एन्कोडिंग के साथ किसी भी चाल का स्वागत है। मैंने कुछ दिनों के लिए इंटरनेट की खोज की है, जो मैंने पहले से लागू किया है उससे ज्यादा कुछ नहीं ढूंढ पा रहा है। यहां विषय पर एक और धागा है, लेकिन ऐसा कोई प्रतीत नहीं होता है। आशा है कि आप मदद कर सकते हैं।

public Bitmap getBitmap(final Context c) { 
    if (bitmap != null) 
     return bitmap; 

    final int rotate = necessaryRotation(c, file); 
    // if(rotate != 0) rotateImageFile(c, rotate); 

    try { 
     // Get scaled version 
     BitmapFactory.Options options = new BitmapFactory.Options(); 
     options.inJustDecodeBounds = true; 
     BitmapFactory.decodeFile(file, options); 
     options.inSampleSize = calcInSampleSize(options, 1024, 1024); 
     options.inJustDecodeBounds = false; 
     bitmap = BitmapFactory.decodeFile(file, options); 

     // rotate? 
     bitmap = rotateImage(c,bitmap,rotate); 

     System.out.println("Bitmap loaded from file: size=" 
       + bitmap.getWidth() + "," + bitmap.getHeight()); 

     System.gc(); 
    } catch (Exception e) { 
     System.err.println("Unable to load image file: " 
       + this.getFilename()); 
    } 

    // if rotation is needed, do it in worker thread for next time 
    if(rotate != 0){ 
     Thread t = new Thread(new Runnable(){ 

      public void run() { 
       // load entire image 
       try{ 
        File imageFile = new File(getFilename()); 
        Bitmap huge = Media.getBitmap(c.getContentResolver(), 
        Uri.fromFile(imageFile)); 

        huge = rotateImage(c,huge,rotate); 

        // save bitmap properly 
        FileOutputStream out = new FileOutputStream(imageFile); 
        huge.compress(Bitmap.CompressFormat.PNG, 100, out); 

        out.flush(); 
        out.close(); 
        huge.recycle(); 
        huge = null; 
        out = null; 
        System.gc(); 

       }catch(IOException e){ 
        e.printStackTrace(); 
       } 
      } 

     }); 
     t.start(); 
    } 

    return bitmap; 
} 

private Bitmap rotateImage(Context c, Bitmap bitmap, int rotate) { 
    if (rotate != 0) { 
     // rotate 
     Matrix m = new Matrix(); 
     m.postRotate(rotate); 
     Bitmap rotImage = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), 
       bitmap.getHeight(), m, true); 
     bitmap.recycle(); 

     System.out.println("Image (id=" + getId() 
       + ") rotated successfully"); 

     System.gc(); 

     return rotImage; 
    } 
    return bitmap; 
} 

private int necessaryRotation(Context c, String imageFile) { 
    int rotate = 0; 
    ExifInterface exif; 
    try { 
     exif = new ExifInterface(imageFile); 
     int orientation = exif.getAttributeInt(
       ExifInterface.TAG_ORIENTATION, 
       ExifInterface.ORIENTATION_NORMAL); 

     switch (orientation) { 
     case ExifInterface.ORIENTATION_ROTATE_270: 
      rotate = 270; 
      break; 
     case ExifInterface.ORIENTATION_ROTATE_180: 
      rotate = 180; 
      break; 
     case ExifInterface.ORIENTATION_ROTATE_90: 
      rotate = 90; 
      break; 
     } 
    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 

    return rotate; 
} 

private int calcInSampleSize(BitmapFactory.Options options, int reqWidth, 
     int reqHeight) { 
    int height = options.outHeight; 
    int width = options.outWidth; 
    int inSampleSize = 1; 
    while (height > reqHeight || width > reqWidth) { 
     height /= 2; 
     width /= 2; 
     inSampleSize *= 2; 
    } 

    return inSampleSize; 
} 

अगर वहाँ कुछ भी आप जानते हैं या किसी अनुकूलन मैं स्मृति उपयोग को कम करने के लिए उपयोग करने के लिए सक्षम हो सकता है की आवश्यकता है, कृपया लिखने :) धन्यवाद

Answer 1

इस स्निपेट का प्रयास है:

private Bitmap rotateImage(Context c, Bitmap bitmap, int rotate) { 
    .... 

    // reduce byte per pixel 
    bitmap = bitmap.copy(Bitmap.Config.RGB_565, false); 

    Bitmap.createBitmap(bitmap,... 
}