Orientacja przechwytywania aparatu na urządzeniach Samsung w Androidzie

Question

Tworzę aplikację dla kamery. Obraz po przechwyceniu jest wyświetlany w widoku siatki. Teraz kod działa całkowicie poprawnie na wszystkich urządzeniach, z wyjątkiem urządzeń Samsung.

Mam do czynienia z problemem orientacji. Kiedy przechwytywam obraz w trybie portretu, obraz obraca się, gdy wyświetlany jest w widoku siatki. Nie trzymałem żadnego kodu rotacyjnego. Po drugie, dzięki EXIF ​​uzyskałem prawidłowy obraz w widoku siatki, ale gdy zmienia się orientacja urządzenia, ponownie obraz obraca się w ponury sposób.

Dołączanie zdjęć:

Przepraszamy za rozdzielczością obrazu. Proszę, niech wiedzą, czy nie są prawidłowo widoczne. Ponownie prześlę. Wiem, że jest tak wiele pomocy na SO. Ale domyślam się, że gdzieś utknąłem.

Mam na myśli na poniższy link:

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

Answer 1

ten kod I Zrobiliśmy to z (działa dla każdego urządzenia):

ta część jest miejscem, w którym ustawiłem zrobione zdjęcie do widoku obrazu w głównej aktywności:

  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); 

stałe wartości aktywności kamery: funkcja

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; 

zwrotna aktywności kamery:

 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();  
      } 
     }; 

odbioru Funkcja Photo aktywności kamery:

 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(); 
     } 

orientacja listenner który nazywa się onr esume aktywności kamery:

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

Oto kod, który użyłem w mojej aplikacji, aby obrócić i działa we wszystkich urządzeniach:

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

Najpierw trzeba uzyskać oryginalny plik 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(); 
        } 

trzeba napisać metodę, która zwrotu Bitmap po obracać go we właściwym kierunku.

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; 
     } 
    }