Orientamento acquisizione fotocamera su dispositivi Samsung in Android

Question

Sto creando un'app per fotocamera. L'immagine catturata viene mostrata nella vista griglia. Ora, il codice funziona perfettamente su tutti i dispositivi ad eccezione dei dispositivi Samsung.

Sono di fronte al problema dell'orientamento. Quando acquisisco un'immagine in modalità verticale, l'immagine ruota quando viene visualizzata nella vista griglia. Non ho mantenuto alcun codice di rotazione. In secondo luogo, con EXIF ​​ho ottenuto l'immagine corretta nella vista a griglia, ma quando l'orientamento del dispositivo cambia, di nuovo l'immagine ruota in modo distorto.

immagini Collegamento:

Ci scusiamo per la risoluzione dell'immagine. Per favore fammi sapere se non sono visibili correttamente. Caricherò di nuovo. So che c'è molto aiuto in SO. Ma credo di essere bloccato da qualche parte.

Mi riferisco al seguente link:

http://blog.andolasoft.com/2013/06/how-to-show-captured-images-dynamically-in-gridview-layout.html

Answer 1

Questo è il codice che ho Ho fatto questo con (funziona per ogni dispositivo):

questa parte è dove ho impostato la foto scattata alla visualizzazione di immagini nell'attività principale:

  try { 
       File imageFile = new File(cursor.getString(0)); 
       ExifInterface exif = new ExifInterface(
         imageFile.getAbsolutePath()); 
       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; 
       } 

       Log.v("", "Exif orientation: " + orientation); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
      Matrix matrix = new Matrix(); 
      matrix.postRotate(rotate); 
      bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true); 
      testImage.setImageBitmap(null); 
      testImage.setImageBitmap(bmp); 

valori costanti nell'attività telecamera: funzione

private static final int ORIENTATION_PORTRAIT_NORMAL = 1; 
    private static final int ORIENTATION_PORTRAIT_INVERTED = 2; 
    private static final int ORIENTATION_LANDSCAPE_NORMAL = 3; 
    private static final int ORIENTATION_LANDSCAPE_INVERTED = 4; 
    private OrientationEventListener mOrientationEventListener; 
    private int mOrientation = -1; 

callback nell'attività macchina: funzione foto

 Camera.PictureCallback photoCallback=new Camera.PictureCallback(){ 
      public void onPictureTaken(final byte[] data, final Camera camera){ 

       dialog=ProgressDialog.show(CameraActivity.this,"","Please wait while the photo is being saved.."); 
       new Thread(){ 
        public void run(){ 
         try{ 
          Thread.sleep(1000);   
         } 
         catch(Exception ex){} 
         onPictureTake(data,camera);  
        } 
       }.start();  
      } 
     }; 

take nell'attività telecamera:

 public void onPictureTake(byte[] data, Camera camera){ 
      switch (mOrientation) { 
      case ORIENTATION_PORTRAIT_NORMAL: 
       rotate = 90; 
       break; 
      case ORIENTATION_LANDSCAPE_NORMAL: 
       rotate = 0; 
       break; 
      case ORIENTATION_PORTRAIT_INVERTED: 
       rotate = 270; 
       break; 
      case ORIENTATION_LANDSCAPE_INVERTED: 
       rotate = 180; 
       break; 
      } 

      Matrix matrix = new Matrix(); 
      matrix.postRotate(rotate); 
      bmp = BitmapFactory.decodeByteArray(data, 0, data.length); 
      bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true); 
      mutableBitmap = bmp.copy(Bitmap.Config.ARGB_8888, true); 
      savePhoto(mutableBitmap); 
      dialog.dismiss(); 
      flag = 0; 
      finish(); 
     } 

orientamento listenner che è chiamato onr esume in attività della fotocamera:

mOrientationEventListener = new OrientationEventListener(this, SensorManager.SENSOR_DELAY_NORMAL) { 

       @SuppressWarnings("deprecation") 
       @Override 
       public void onOrientationChanged(int orientation) { 

        // determine our orientation based on sensor response 
        int lastOrientation = mOrientation; 

        Display display = ((WindowManager)getSystemService(WINDOW_SERVICE)).getDefaultDisplay(); 
        int rotation = getWindowManager().getDefaultDisplay().getRotation(); 
        System.out.println(rotation+""); 

       if (display.getOrientation() != Surface.ROTATION_0) { // landscape oriented devices 
         System.out.println("LANDSCAPE"); 
         if (orientation >= 315 || orientation < 45) { 
          if (mOrientation != ORIENTATION_LANDSCAPE_NORMAL) {       
           mOrientation = ORIENTATION_LANDSCAPE_NORMAL; 
          } 
         } else if (orientation < 315 && orientation >= 225) { 
          if (mOrientation != ORIENTATION_PORTRAIT_INVERTED) { 
           mOrientation = ORIENTATION_PORTRAIT_INVERTED; 
          }      
         } else if (orientation < 225 && orientation >= 135) { 
          if (mOrientation != ORIENTATION_LANDSCAPE_INVERTED) { 
           mOrientation = ORIENTATION_LANDSCAPE_INVERTED; 
          }      
         } else if (orientation <135 && orientation > 45) { 
          if (mOrientation != ORIENTATION_PORTRAIT_NORMAL) { 
           mOrientation = ORIENTATION_PORTRAIT_NORMAL; 
          }      
         }      
        } else { // portrait oriented devices 
         System.out.println("PORTRAIT"); 
         if (orientation >= 315 || orientation < 45) { 
          if (mOrientation != ORIENTATION_PORTRAIT_NORMAL) {       
           mOrientation = ORIENTATION_PORTRAIT_NORMAL; 
          } 
         } else if (orientation < 315 && orientation >= 225) { 
          if (mOrientation != ORIENTATION_LANDSCAPE_NORMAL) { 
           mOrientation = ORIENTATION_LANDSCAPE_NORMAL; 
          }      
         } else if (orientation < 225 && orientation >= 135) { 
          if (mOrientation != ORIENTATION_PORTRAIT_INVERTED) { 
           mOrientation = ORIENTATION_PORTRAIT_INVERTED; 
          }      
         } else if (orientation <135 && orientation > 45) { 
          if (mOrientation != ORIENTATION_LANDSCAPE_INVERTED) { 
           mOrientation = ORIENTATION_LANDSCAPE_INVERTED; 
          }      
         } 
        } 

       } 
      }; 

Answer 2

Ecco il codice che ho usato nella mia app per ruotare e lavora a tutti i dispositivi:

private Bitmap adjustImageOrientation(Bitmap image) { 
     ExifInterface exif; 
     try { 
      exif = new ExifInterface(picturePath); 
      int exifOrientation = exif.getAttributeInt(
        ExifInterface.TAG_ORIENTATION, 
        ExifInterface.ORIENTATION_NORMAL); 

      int rotate = 0; 
      switch (exifOrientation) { 
      case ExifInterface.ORIENTATION_ROTATE_90: 
       rotate = 90; 
       break; 

      case ExifInterface.ORIENTATION_ROTATE_180: 
       rotate = 180; 
       break; 

      case ExifInterface.ORIENTATION_ROTATE_270: 
       rotate = 270; 
       break; 
      } 

      if (rotate != 0) { 
       int w = image.getWidth(); 
       int h = image.getHeight(); 

       // Setting pre rotate 
       Matrix mtx = new Matrix(); 
       mtx.preRotate(rotate); 

       // Rotating Bitmap & convert to ARGB_8888, required by tess 
       image = Bitmap.createBitmap(image, 0, 0, w, h, mtx, false); 

      } 
     } catch (IOException e) { 
       return null; 
     } 
     return image.copy(Bitmap.Config.ARGB_8888, true); 
    } 

Answer 3

In primo luogo è necessario ottenere il file originale orientation--

 try { 
         ExifInterface exif = new ExifInterface("File AbsolutePath"); 
         int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED); 
         Bitmap bm = rotateBitmap("Old Bitmap", orientation); 
        } catch (IOException e) { 
         e.printStackTrace(); 
        } 

Hai bisogno di scrivere un metodo che restituisce il bitmap dopo ruotarlo nella direzione giusta.

public Bitmap rotateBitmap(Bitmap bitmap, int orientation) throws IOException { 

     Matrix matrix = new Matrix(); 
     switch (orientation) { 
     case ExifInterface.ORIENTATION_NORMAL: 
      return bitmap; 
     case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: 
      matrix.setScale(-1, 1); 
      break; 
     case ExifInterface.ORIENTATION_ROTATE_180: 
      matrix.setRotate(180); 
      break; 
     case ExifInterface.ORIENTATION_FLIP_VERTICAL: 
      matrix.setRotate(180); 
      matrix.postScale(-1, 1); 
      break; 
     case ExifInterface.ORIENTATION_TRANSPOSE: 
      matrix.setRotate(90); 
      matrix.postScale(-1, 1); 
      break; 
     case ExifInterface.ORIENTATION_ROTATE_90: 
      matrix.setRotate(90); 
      break; 
     case ExifInterface.ORIENTATION_TRANSVERSE: 
      matrix.setRotate(-90); 
      matrix.postScale(-1, 1); 
      break; 
     case ExifInterface.ORIENTATION_ROTATE_270: 
      matrix.setRotate(-90); 
      break; 
     default: 
      return bitmap; 
     } 
     try { 
      Bitmap bmRotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); 
      bitmap.recycle(); 
      return bmRotated; 
     } catch (OutOfMemoryError e) { 
      e.printStackTrace(); 
      return null; 
     } 
    }