왜 'exif.setAttribute (ExifInterface.TAG_ORIENTATION, String.valueOf (ExifInterface.ORIENTATION_ROTATE_270));'는 아무것도하지 않습니까?

Question

내 앱이 세로로 사진을 찍습니다. 갤러리에서

나는

하지만 내 서버에 저장하면 내가 풍경에서 볼 OK를 참조하십시오.

나는 이것이 무엇을 의미합니까 내 이미지 파일을 확인하고

ORIENTATION_ROTATE_90

을 가지고있다?

나는 ORIENTATION_NORAML로 설정하기 위해 시도했지만 아직이

 ExifInterface exif; 
     try { 
      exif = new ExifInterface(imageFilename); 
      int orientation = 
       exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
      exif.setAttribute(ExifInterface.TAG_ORIENTATION, 
       String.valueOf(ExifInterface.ORIENTATION_ROTATE_270)); 
//also tried ExifInterface.ORIENTATION_ROTATE_UNDEFINED) 
      exif.saveAttributes(); 
      orientation = 
       exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
      boolean b = orientation == Configuration.ORIENTATION_LANDSCAPE; 

     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

가 어떻게이 문제를 해결할 수 있습니다 (가로 또는 세로로 촬영 여부를) 만 풍경에 저장?

Answer 1

,이 당신이 당신의 문제를 해결하는 데 도움이 될 것입니다 희망이 방법을 시도 ...

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" 
    android:orientation="vertical" > 

    <LinearLayout 
     android:layout_width="match_parent" 
     android:layout_height="0dp" 
     android:layout_weight="1" 
     android:gravity="center"> 

     <ImageView 
      android:id="@+id/imgFromCameraOrGallery" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" 
      android:adjustViewBounds="true" 
      android:src="@drawable/ic_launcher"/> 

    </LinearLayout> 
    <LinearLayout 
     android:layout_width="match_parent" 
     android:layout_height="wrap_content"> 
     <Button 
      android:id="@+id/btnCamera" 
      android:layout_width="0dp" 
      android:layout_height="wrap_content" 
      android:layout_weight="1" 
      android:text="Camera"/> 
     <Button 
      android:id="@+id/btnGallery" 
      android:layout_width="0dp" 
      android:layout_height="wrap_content" 
      android:layout_weight="1" 
      android:text="Gallery"/> 
    </LinearLayout> 
</LinearLayout> 

MainActivity.java

public class MainActivity extends Activity { 

    private ImageView imgFromCameraOrGallery; 
    private Button btnCamera; 
    private Button btnGallery; 

    private String imgPath; 
    final private int PICK_IMAGE = 1; 
    final private int CAPTURE_IMAGE = 2; 
    private File mFileTemp; 
    public String TEMP_PHOTO_FILE_NAME = "temp_photo.jpg"; 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     imgFromCameraOrGallery = (ImageView) findViewById(R.id.imgFromCameraOrGallery); 
     btnCamera = (Button) findViewById(R.id.btnCamera); 
     btnGallery = (Button) findViewById(R.id.btnGallery); 

     String state = Environment.getExternalStorageState(); 
     if (Environment.MEDIA_MOUNTED.equals(state)) { 
      mFileTemp = new File(Environment.getExternalStorageDirectory(), TEMP_PHOTO_FILE_NAME); 
     } 
     else { 
      mFileTemp = new File(getFilesDir(), TEMP_PHOTO_FILE_NAME); 
     } 

     btnCamera.setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       final Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); 
       intent.putExtra(MediaStore.EXTRA_OUTPUT, setImageUri()); 
       startActivityForResult(intent, CAPTURE_IMAGE); 
      } 
     }); 

     btnGallery.setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       Intent intent = new Intent(); 
       intent.setType("image/*"); 
       intent.setAction(Intent.ACTION_GET_CONTENT); 
       startActivityForResult(Intent.createChooser(intent, ""), PICK_IMAGE); 
      } 
     }); 


    } 

    @Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
     super.onActivityResult(requestCode, resultCode, data); 
     if (resultCode == Activity.RESULT_OK) { 
      if (requestCode == CAPTURE_IMAGE) { 
       try { 
        InputStream inputStream = getContentResolver().openInputStream(getImageUri(getImagePath())); 
        FileOutputStream fileOutputStream = new FileOutputStream(mFileTemp); 
        copyStream(inputStream, fileOutputStream); 
        fileOutputStream.close(); 
        inputStream.close(); 
       }catch (Throwable e){ 
        e.printStackTrace(); 
       } 
       rotateImage(mFileTemp); 
      } else if (requestCode == PICK_IMAGE) { 
       imgFromCameraOrGallery.setImageBitmap(BitmapFactory.decodeFile(getAbsolutePath(data.getData()))); 
      } 
     } 

    } 

    private void rotateImage(final File file) { 
     runOnUiThread(new Runnable() { 
      @Override 
      public void run() { 
       Bitmap b = decodeFileFromPath(file.getPath()); 
       try { 
        ExifInterface ei = new ExifInterface(file.getPath()); 
        int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
        Matrix matrix = new Matrix(); 
        switch (orientation) { 
         case ExifInterface.ORIENTATION_ROTATE_90: 
          matrix.postRotate(90); 
          b = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, true); 
          break; 
         case ExifInterface.ORIENTATION_ROTATE_180: 
          matrix.postRotate(180); 
          b = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, true); 
          break; 
         case ExifInterface.ORIENTATION_ROTATE_270: 
          matrix.postRotate(270); 
          b = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, true); 
          break; 
         default: 
          b = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, true); 
          break; 
        } 
       } catch (Throwable e) { 
        e.printStackTrace(); 
       } 

       FileOutputStream out1 = null; 
       try { 
        if (mFileTemp.exists()) 
         mFileTemp.delete(); 
        String state = Environment.getExternalStorageState(); 
        if (Environment.MEDIA_MOUNTED.equals(state)) { 
         mFileTemp = new File(Environment.getExternalStorageDirectory(), TEMP_PHOTO_FILE_NAME); 
        } else { 
         mFileTemp = new File(getFilesDir(), TEMP_PHOTO_FILE_NAME); 
        } 
        out1 = new FileOutputStream(mFileTemp); 
        b.compress(Bitmap.CompressFormat.JPEG, 90, out1); 
       } catch (Exception e) { 
        e.printStackTrace(); 
       } finally { 
        try { 
         out1.close(); 
        } catch (Throwable ignore) { 

        } 
       } 
       imgFromCameraOrGallery.setImageBitmap(BitmapFactory.decodeFile(mFileTemp.getAbsolutePath())); 
      } 
     }); 

    } 

    private Bitmap decodeFileFromPath(String path){ 
     Uri uri = getImageUri(path); 
     InputStream in = null; 
     try { 
      in = getContentResolver().openInputStream(uri); 

      //Decode image size 
      BitmapFactory.Options o = new BitmapFactory.Options(); 
      o.inJustDecodeBounds = true; 

      BitmapFactory.decodeStream(in, null, o); 
      in.close(); 


      int scale = 1; 
      int inSampleSize = 1024; 
      if (o.outHeight > inSampleSize || o.outWidth > inSampleSize) { 
       scale = (int) Math.pow(2, (int) Math.round(Math.log(inSampleSize/(double) Math.max(o.outHeight, o.outWidth))/Math.log(0.5))); 
      } 

      BitmapFactory.Options o2 = new BitmapFactory.Options(); 
      o2.inSampleSize = scale; 
      in = getContentResolver().openInputStream(uri); 
      Bitmap b = BitmapFactory.decodeStream(in, null, o2); 
      in.close(); 

      return b; 

     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
     return null; 
    } 

    public String getAbsolutePath(Uri uri) { 
     if(Build.VERSION.SDK_INT >= 19){ 
      String id = uri.getLastPathSegment().split(":")[1]; 
      final String[] imageColumns = {MediaStore.Images.Media.DATA }; 
      final String imageOrderBy = null; 
      Uri tempUri = getUri(); 
      Cursor imageCursor = getContentResolver().query(tempUri, imageColumns, 
        MediaStore.Images.Media._ID + "="+id, null, imageOrderBy); 
      if (imageCursor.moveToFirst()) { 
       return imageCursor.getString(imageCursor.getColumnIndex(MediaStore.Images.Media.DATA)); 
      }else{ 
       return null; 
      } 
     }else{ 
      String[] projection = { MediaStore.MediaColumns.DATA }; 
      Cursor cursor = getContentResolver().query(uri, projection, null, null, null); 
      if (cursor != null) { 
       int column_index = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA); 
       cursor.moveToFirst(); 
       return cursor.getString(column_index); 
      } else 
       return null; 
     } 

    } 

    private Uri getUri() { 
     String state = Environment.getExternalStorageState(); 
     if(!state.equalsIgnoreCase(Environment.MEDIA_MOUNTED)) 
      return MediaStore.Images.Media.INTERNAL_CONTENT_URI; 

     return MediaStore.Images.Media.EXTERNAL_CONTENT_URI; 
    } 

    private Uri getImageUri(String path) { 
     return Uri.fromFile(new File(path)); 
    } 

    public void copyStream(InputStream input, OutputStream output) 
      throws IOException { 

     byte[] buffer = new byte[1024]; 
     int bytesRead; 
     while ((bytesRead = input.read(buffer)) != -1) { 
      output.write(buffer, 0, bytesRead); 
     } 
    } 

    public Uri setImageUri() { 
     // Store image in dcim 
     File file = new File(Environment.getExternalStorageDirectory() + "/DCIM/", "image" + new Date().getTime() + ".jpg"); 
     Uri imgUri = Uri.fromFile(file); 
     this.imgPath = file.getAbsolutePath(); 
     return imgUri; 
    } 

    public String getImagePath() { 
     return imgPath; 
    } 
} 

기본적으로