android captured image to be in portrait

Question

In my app i need to upload some images from my mobiles gallery page.

I am using Samsung Galaxy ace and i have captured image some images in portrait mode using the default camera of the mobile. After capturing i opened those images in my app and tried to show it in image view. The images which are been captured in portrait mode seems to be in landscape in image view.

Using the exifInterface.getAttribute(ExifInterface.TAG_ORIENTATION) i checked the images orientation value to be as 6.

Using the following code i am showing the image in portrait mode in image view,

 Matrix matrix = new Matrix();
                       matrix.postRotate(90);
                       bitmap = BitmapFactory.decodeStream(getContentResolver().openInputStream(HomePage._uri));
                       bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
                       i.setImageBitmap(bitmap);

But after uploading the image and retrieving it in another activity of my app it seems to be again in landscape mode. How to upload the image in portrait itself ?

I have captured in Portrait , i have showed it in portrait by myself, while uploading it i need it to be in portrait itself, so that when i am retrieving it i can view it in portrait mode,

how to get this done, (for capturing i dint use the camera in my app, i captured using the mobiles default camera, outside the app)

Answer 1

i have found the solution to get the image from gallery and uploading it. Some images selected from gallery may look rotated, in that case the following solution works good

Select image from gallery

Intent intent = new Intent(Intent.ACTION_PICK,  android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
        intent.setType("image/*");
        startActivityForResult(intent, 2); 

Next in onActivityResult

public void onActivityResult(int requestCode, int resultCode, final Intent data) 
    {
        super.onActivityResult(requestCode, resultCode, data);
        if(resultCode == Activity.RESULT_OK )
        {
            f(requestCode == 2)
            {   
                try 
                {
                String [] proj = { MediaStore.Images.Media.DATA };  
                Cursor cursor = managedQuery(data.getData(), proj, null, null, null);  
                int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);  
                cursor.moveToFirst();  
                pathInput = cursor.getString(column_index); 

                Appconstants.f = Environment.getExternalStorageDirectory() + "/tmp_siva.jpg";
                ImageUtils.resampleImageAndSaveToNewLocation(pathInput, Appconstants.f);
                }
                catch (Exception ex) 
                {
                Log.e("Exception ex @ try catch",""+ex);
                }
            }
            }             
    }

Here is the ImageUtils class

public class ImageUtils 
{
     private ImageUtils() 
     {
     }

     public static void resampleImageAndSaveToNewLocation(String pathInput, String pathOutput) throws Exception 
     {
         Bitmap bmp = resampleImage(pathInput, 800);

         OutputStream out = new FileOutputStream(pathOutput);
         bmp.compress(Bitmap.CompressFormat.JPEG, 100, out); 
    }

    public static Bitmap resampleImage(String path, int maxDim) throws Exception 
    {        
        BitmapFactory.Options bfo = new BitmapFactory.Options(); 
        bfo.inJustDecodeBounds = true; 
        BitmapFactory.decodeFile(path, bfo); 

        BitmapFactory.Options optsDownSample = new BitmapFactory.Options();
        optsDownSample.inSampleSize = getClosestResampleSize(bfo.outWidth, bfo.outHeight, maxDim);

        Bitmap bmpt = BitmapFactory.decodeFile(path, optsDownSample);

        Matrix m = new Matrix(); 

        if (bmpt.getWidth() > maxDim || bmpt.getHeight() > maxDim) 
        {           
            BitmapFactory.Options optsScale = getResampling(bmpt.getWidth(), bmpt.getHeight(), maxDim);
            m.postScale((float)optsScale.outWidth  / (float)bmpt.getWidth(), (float)optsScale.outHeight / (float)bmpt.getHeight()); 
            }

        int sdk = new Integer(Build.VERSION.SDK).intValue(); 
        if (sdk > 4) 
        {
            int rotation = ExifUtils.getExifRotation(path);
            if (rotation != 0) 
            { 
                m.postRotate(rotation); 
            }
        }

        return Bitmap.createBitmap(bmpt, 0, 0, bmpt.getWidth(), bmpt.getHeight(), m, true); 
    }

    private static BitmapFactory.Options getResampling(int cx, int cy, int max) 
    {
        float scaleVal = 1.0f;
        BitmapFactory.Options bfo = new BitmapFactory.Options();
        if (cx > cy) 
        {
            scaleVal = (float)max / (float)cx;
        }
        else if (cy > cx) 
        {
            scaleVal = (float)max / (float)cy;
        }
        else 
        {
            scaleVal = (float)max / (float)cx;
        }
        bfo.outWidth  = (int)(cx * scaleVal + 0.5f);
        bfo.outHeight = (int)(cy * scaleVal + 0.5f);
        return bfo;
    }

    private static int getClosestResampleSize(int cx, int cy, int maxDim) 
    {
        /*Log.e("cx",""+cx);
        Log.e("cy",""+cy);*/
        int max = Math.max(cx, cy);

        int resample = 1;
        for (resample = 1; resample < Integer.MAX_VALUE; resample++) 
        {
            if (resample * maxDim > max) 
            {
                resample--;
                break;
            }
        }

        if (resample > 0) 
        {
            return resample;
        }
        return 1;
    }

    public static BitmapFactory.Options getBitmapDims(String path) throws Exception 
    {
        BitmapFactory.Options bfo = new BitmapFactory.Options(); 
        bfo.inJustDecodeBounds = true; 
        BitmapFactory.decodeFile(path, bfo); 
        return bfo;
    }
}

Here is the Exif class

public class ExifUtils 
{
    private ExifUtils() 
    {
    }

    public static int getExifRotation(String imgPath) 
    {
        try 
        {
            ExifInterface exif = new ExifInterface(imgPath);
            String rotationAmount = exif.getAttribute(ExifInterface.TAG_ORIENTATION);
            if (!TextUtils.isEmpty(rotationAmount)) 
            {
                int rotationParam = Integer.parseInt(rotationAmount);
                switch (rotationParam) 
                {
                    case ExifInterface.ORIENTATION_NORMAL:
                        return 0;
                    case ExifInterface.ORIENTATION_ROTATE_90:
                        return 90;
                    case ExifInterface.ORIENTATION_ROTATE_180:
                        return 180;
                    case ExifInterface.ORIENTATION_ROTATE_270:
                        return 270;
                    default:
                        return 0;
                }
            } 
            else 
            {
                return 0;
            }
        }
        catch (Exception ex) 
        {
            return 0;
        }
    }
}

The image gets selected in gallery is been checked whether of portrait or landscape type and been rotated and saved in a new path in sdcard. To avoid OOM issue its been resized.