Hot, um Bilder in der richtigen Orientierung mit CAMERA2 zu speichern

Question

Hier ist mein Kamera-Fragment, in dem ich die Kamera mit TextureView öffnen. Die Kamera ist Aufnahme des Bildes in der richtigen Orientierung, aber das erfasste Bild wird nicht in der richtigen Ausrichtung gespeichert zu werden ...

public class Camera2BasicFragment extends Fragment 
     implements View.OnClickListener, FragmentCompat.OnRequestPermissionsResultCallback { 

    private static final SparseIntArray ORIENTATIONS = new SparseIntArray(); 
    private static final int REQUEST_CAMERA_PERMISSION = 1; 
    private static final String FRAGMENT_DIALOG = "dialog"; 

    static { 
     ORIENTATIONS.append(Surface.ROTATION_0, 90); 
     ORIENTATIONS.append(Surface.ROTATION_90, 0); 
     ORIENTATIONS.append(Surface.ROTATION_180, 270); 
     ORIENTATIONS.append(Surface.ROTATION_270, 180); 
    } 

    private static final String TAG = "Camera2BasicFragment"; 
    private static final int STATE_PREVIEW = 0; 
    private static final int STATE_WAITING_LOCK = 1; 
    private static final int STATE_WAITING_PRECAPTURE = 2; 
    private static final int STATE_WAITING_NON_PRECAPTURE = 3; 
    private static final int STATE_PICTURE_TAKEN = 4; 
    private static final int MAX_PREVIEW_WIDTH = 1920; 
    private static final int MAX_PREVIEW_HEIGHT = 1080; 
    private final TextureView.SurfaceTextureListener mSurfaceTextureListener 
      = new TextureView.SurfaceTextureListener() { 

     @Override 
     public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) { 
      openCamera(width, height); 
     } 

     @Override 
     public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) { 
      configureTransform(width, height); 
     } 

     @Override 
     public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) { 
      return true; 
     } 

     @Override 
     public void onSurfaceTextureUpdated(SurfaceTexture texture) { 
     } 

    }; 

    private String mCameraId; 
    private AutoFitTextureView mTextureView; 
    private CameraCaptureSession mCaptureSession; 
    private CameraDevice mCameraDevice; 
    private Size mPreviewSize; 
    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() { 

     @Override 
     public void onOpened(@NonNull CameraDevice cameraDevice) { 
      mCameraOpenCloseLock.release(); 
      mCameraDevice = cameraDevice; 
      createCameraPreviewSession(); 
     } 

     @Override 
     public void onDisconnected(@NonNull CameraDevice cameraDevice) { 
      mCameraOpenCloseLock.release(); 
      cameraDevice.close(); 
      mCameraDevice = null; 
     } 

     @Override 
     public void onError(@NonNull CameraDevice cameraDevice, int error) { 
      mCameraOpenCloseLock.release(); 
      cameraDevice.close(); 
      mCameraDevice = null; 
      Activity activity = getActivity(); 
      if (null != activity) { 
       activity.finish(); 
      } 
     } 

    }; 

    private HandlerThread mBackgroundThread; 

    private Handler mBackgroundHandler; 
    private ImageReader mImageReader; 
    private File mFile; 
    private final ImageReader.OnImageAvailableListener mOnImageAvailableListener 
      = new ImageReader.OnImageAvailableListener() { 

     @Override 
     public void onImageAvailable(ImageReader reader) { 
      mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile)); 
     } 

    }; 

    private CaptureRequest.Builder mPreviewRequestBuilder; 
    private CaptureRequest mPreviewRequest; 
    private int mState = STATE_PREVIEW; 
    private Semaphore mCameraOpenCloseLock = new Semaphore(1); 
    private boolean mFlashSupported; 
    private int mSensorOrientation; 
    private CameraCaptureSession.CaptureCallback mCaptureCallback 
      = new CameraCaptureSession.CaptureCallback() { 

     private void process(CaptureResult result) { 
      switch (mState) { 
       case STATE_PREVIEW: { 
        // We have nothing to do when the camera preview is working normally. 
        break; 
       } 
       case STATE_WAITING_LOCK: { 
        Integer afState = result.get(CaptureResult.CONTROL_AF_STATE); 
        if (afState == null) { 
         captureStillPicture(); 
        } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || 
          CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) { 
         // CONTROL_AE_STATE can be null on some devices 
         Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); 
         if (aeState == null || 
           aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) { 
          mState = STATE_PICTURE_TAKEN; 
          captureStillPicture(); 
         } else { 
          runPrecaptureSequence(); 
         } 
        } 
        break; 
       } 
       case STATE_WAITING_PRECAPTURE: { 

        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); 
        if (aeState == null || 
          aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE || 
          aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) { 
         mState = STATE_WAITING_NON_PRECAPTURE; 
        } 
        break; 
       } 
       case STATE_WAITING_NON_PRECAPTURE: { 
        // CONTROL_AE_STATE can be null on some devices 
        Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE); 
        if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) { 
         mState = STATE_PICTURE_TAKEN; 
         captureStillPicture(); 
        } 
        break; 
       } 
      } 
     } 

     @Override 
     public void onCaptureProgressed(@NonNull CameraCaptureSession session, 
             @NonNull CaptureRequest request, 
             @NonNull CaptureResult partialResult) { 
      process(partialResult); 
     } 

     @Override 
     public void onCaptureCompleted(@NonNull CameraCaptureSession session, 
             @NonNull CaptureRequest request, 
             @NonNull TotalCaptureResult result) { 
      process(result); 
     } 

    }; 

    private void showToast(final String text) { 
     final Activity activity = getActivity(); 
     if (activity != null) { 
      activity.runOnUiThread(new Runnable() { 
       @Override 
       public void run() { 
        Toast.makeText(activity, text, Toast.LENGTH_SHORT).show(); 
       } 
      }); 
     } 
    } 

    private static Size chooseOptimalSize(Size[] choices, int textureViewWidth, 
      int textureViewHeight, int maxWidth, int maxHeight, Size aspectRatio) { 

     List<Size> bigEnough = new ArrayList<>(); 
     List<Size> notBigEnough = new ArrayList<>(); 
     int w = aspectRatio.getWidth(); 
     int h = aspectRatio.getHeight(); 
     for (Size option : choices) { 
      if (option.getWidth() <= maxWidth && option.getHeight() <= maxHeight && 
        option.getHeight() == option.getWidth() * h/w) { 
       if (option.getWidth() >= textureViewWidth && 
        option.getHeight() >= textureViewHeight) { 
        bigEnough.add(option); 
       } else { 
        notBigEnough.add(option); 
       } 
      } 
     } 

     if (bigEnough.size() > 0) { 
      return Collections.min(bigEnough, new CompareSizesByArea()); 
     } else if (notBigEnough.size() > 0) { 
      return Collections.max(notBigEnough, new CompareSizesByArea()); 
     } else { 
      Log.e(TAG, "Couldn't find any suitable preview size"); 
      return choices[0]; 
     } 
    } 

    public static Camera2BasicFragment newInstance() { 
     return new Camera2BasicFragment(); 
    } 

    @Override 
    public View onCreateView(LayoutInflater inflater, ViewGroup container, 
          Bundle savedInstanceState) { 
     return inflater.inflate(R.layout.fragment_camera2_basic, container, false); 
    } 

    @Override 
    public void onViewCreated(final View view, Bundle savedInstanceState) { 
     view.findViewById(R.id.picture).setOnClickListener(this); 
     view.findViewById(R.id.info).setOnClickListener(this); 
     mTextureView = (AutoFitTextureView) view.findViewById(R.id.texture); 
    } 

    @Override 
    public void onActivityCreated(Bundle savedInstanceState) { 
     super.onActivityCreated(savedInstanceState); 
     mFile = new File(getActivity().getExternalFilesDir(null), "pic.jpg"); 
    } 

    @Override 
    public void onResume() { 
     super.onResume(); 
     startBackgroundThread(); 


     if (mTextureView.isAvailable()) { 
      openCamera(mTextureView.getWidth(), mTextureView.getHeight()); 
     } else { 
      mTextureView.setSurfaceTextureListener(mSurfaceTextureListener); 
     } 
    } 

    @Override 
    public void onPause() { 
     closeCamera(); 
     stopBackgroundThread(); 
     super.onPause(); 
    } 

    private void requestCameraPermission() { 
     if (FragmentCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) { 
      new ConfirmationDialog().show(getChildFragmentManager(), FRAGMENT_DIALOG); 
     } else { 
      FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, 
        REQUEST_CAMERA_PERMISSION); 
     } 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, 
              @NonNull int[] grantResults) { 
     if (requestCode == REQUEST_CAMERA_PERMISSION) { 
      if (grantResults.length != 1 || grantResults[0] != PackageManager.PERMISSION_GRANTED) { 
       ErrorDialog.newInstance(getString(R.string.request_permission)) 
         .show(getChildFragmentManager(), FRAGMENT_DIALOG); 
      } 
     } else { 
      super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
     } 
    } 

    private void setUpCameraOutputs(int width, int height) { 
     Activity activity = getActivity(); 
     CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE); 
     try { 
      for (String cameraId : manager.getCameraIdList()) { 
       CameraCharacteristics characteristics 
         = manager.getCameraCharacteristics(cameraId); 

       // We don't use a front facing camera in this sample. 
       Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING); 
       if (facing != null && facing == CameraCharacteristics.LENS_FACING_FRONT) { 
        continue; 
       } 

       StreamConfigurationMap map = characteristics.get(
         CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); 
       if (map == null) { 
        continue; 
       } 


       Size largest = Collections.max(
         Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), 
         new CompareSizesByArea()); 
       mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), 
         ImageFormat.JPEG, /*maxImages*/2); 
       mImageReader.setOnImageAvailableListener(
         mOnImageAvailableListener, mBackgroundHandler); 

       int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation(); 
       //noinspection ConstantConditions 
       mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); 
       boolean swappedDimensions = false; 
       switch (displayRotation) { 
        case Surface.ROTATION_0: 
        case Surface.ROTATION_180: 
         if (mSensorOrientation == 90 || mSensorOrientation == 270) { 
          swappedDimensions = true; 
         } 
         break; 
        case Surface.ROTATION_90: 
        case Surface.ROTATION_270: 
         if (mSensorOrientation == 0 || mSensorOrientation == 180) { 
          swappedDimensions = true; 
         } 
         break; 
        default: 
         Log.e(TAG, "Display rotation is invalid: " + displayRotation); 
       } 

       Point displaySize = new Point(); 
       activity.getWindowManager().getDefaultDisplay().getSize(displaySize); 
       int rotatedPreviewWidth = width; 
       int rotatedPreviewHeight = height; 
       int maxPreviewWidth = displaySize.x; 
       int maxPreviewHeight = displaySize.y; 

       if (swappedDimensions) { 
        rotatedPreviewWidth = height; 
        rotatedPreviewHeight = width; 
        maxPreviewWidth = displaySize.y; 
        maxPreviewHeight = displaySize.x; 
       } 

       if (maxPreviewWidth > MAX_PREVIEW_WIDTH) { 
        maxPreviewWidth = MAX_PREVIEW_WIDTH; 
       } 

       if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) { 
        maxPreviewHeight = MAX_PREVIEW_HEIGHT; 
       } 

       mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), 
         rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth, 
         maxPreviewHeight, largest); 

       int orientation = getResources().getConfiguration().orientation; 
       if (orientation == Configuration.ORIENTATION_LANDSCAPE) { 
        mTextureView.setAspectRatio(
          mPreviewSize.getWidth(), mPreviewSize.getHeight()); 
       } else { 
        mTextureView.setAspectRatio(
          mPreviewSize.getHeight(), mPreviewSize.getWidth()); 
       } 

       Boolean available = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE); 
       mFlashSupported = available == null ? false : available; 

       mCameraId = cameraId; 
       return; 
      } 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } catch (NullPointerException e) { 
      ErrorDialog.newInstance(getString(R.string.camera_error)) 
        .show(getChildFragmentManager(), FRAGMENT_DIALOG); 
     } 
    } 

    private void openCamera(int width, int height) { 
     if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA) 
       != PackageManager.PERMISSION_GRANTED) { 
      requestCameraPermission(); 
      return; 
     } 
     setUpCameraOutputs(width, height); 
     configureTransform(width, height); 
     Activity activity = getActivity(); 
     CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE); 
     try { 
      if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) { 
       throw new RuntimeException("Time out waiting to lock camera opening."); 
      } 
      manager.openCamera(mCameraId, mStateCallback, mBackgroundHandler); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } catch (InterruptedException e) { 
      throw new RuntimeException("Interrupted while trying to lock camera opening.", e); 
     } 
    } 

    private void closeCamera() { 
     try { 
      mCameraOpenCloseLock.acquire(); 
      if (null != mCaptureSession) { 
       mCaptureSession.close(); 
       mCaptureSession = null; 
      } 
      if (null != mCameraDevice) { 
       mCameraDevice.close(); 
       mCameraDevice = null; 
      } 
      if (null != mImageReader) { 
       mImageReader.close(); 
       mImageReader = null; 
      } 
     } catch (InterruptedException e) { 
      throw new RuntimeException("Interrupted while trying to lock camera closing.", e); 
     } finally { 
      mCameraOpenCloseLock.release(); 
     } 
    } 

    private void startBackgroundThread() { 
     mBackgroundThread = new HandlerThread("CameraBackground"); 
     mBackgroundThread.start(); 
     mBackgroundHandler = new Handler(mBackgroundThread.getLooper()); 
    } 

    private void stopBackgroundThread() { 
     mBackgroundThread.quitSafely(); 
     try { 
      mBackgroundThread.join(); 
      mBackgroundThread = null; 
      mBackgroundHandler = null; 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
    } 

    private void createCameraPreviewSession() { 
     try { 
      SurfaceTexture texture = mTextureView.getSurfaceTexture(); 
      assert texture != null; 

      texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight()); 

      Surface surface = new Surface(texture); 

      mPreviewRequestBuilder 
        = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW); 
      mPreviewRequestBuilder.addTarget(surface); 

      mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), 
        new CameraCaptureSession.StateCallback() { 

         @Override 
         public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) { 
          // The camera is already closed 
          if (null == mCameraDevice) { 
           return; 
          } 

          mCaptureSession = cameraCaptureSession; 
          try { 
           mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, 
             CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); 
           setAutoFlash(mPreviewRequestBuilder); 

           mPreviewRequest = mPreviewRequestBuilder.build(); 
           mCaptureSession.setRepeatingRequest(mPreviewRequest, 
             mCaptureCallback, mBackgroundHandler); 
          } catch (CameraAccessException e) { 
           e.printStackTrace(); 
          } 
         } 

         @Override 
         public void onConfigureFailed(
           @NonNull CameraCaptureSession cameraCaptureSession) { 
          showToast("Failed"); 
         } 
        }, null 
      ); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } 
    } 

    private void configureTransform(int viewWidth, int viewHeight) { 
     Activity activity = getActivity(); 
     if (null == mTextureView || null == mPreviewSize || null == activity) { 
      return; 
     } 
     int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); 
     Matrix matrix = new Matrix(); 
     RectF viewRect = new RectF(0, 0, viewWidth, viewHeight); 
     RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth()); 
     float centerX = viewRect.centerX(); 
     float centerY = viewRect.centerY(); 
     if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) { 
      bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY()); 
      matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL); 
      float scale = Math.max(
        (float) viewHeight/mPreviewSize.getHeight(), 
        (float) viewWidth/mPreviewSize.getWidth()); 
      matrix.postScale(scale, scale, centerX, centerY); 
      matrix.postRotate(90 * (rotation - 2), centerX, centerY); 
     } else if (Surface.ROTATION_180 == rotation) { 
      matrix.postRotate(180, centerX, centerY); 
     } 
     mTextureView.setTransform(matrix); 
    } 

    private void takePicture() { 
     lockFocus(); 
    } 

    private void lockFocus() { 
     try { 

      mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 
        CameraMetadata.CONTROL_AF_TRIGGER_START); 
      // Tell #mCaptureCallback to wait for the lock. 
      mState = STATE_WAITING_LOCK; 
      mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, 
        mBackgroundHandler); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } 
    } 

    private void runPrecaptureSequence() { 
     try { 
      mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, 
        CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START); 

      mState = STATE_WAITING_PRECAPTURE; 
      mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, 
        mBackgroundHandler); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } 
    } 

    private void captureStillPicture() { 
     try { 
      final Activity activity = getActivity(); 
      if (null == activity || null == mCameraDevice) { 
       return; 
      } 
      final CaptureRequest.Builder captureBuilder = 
        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE); 
      captureBuilder.addTarget(mImageReader.getSurface()); 

      captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, 
        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE); 
      setAutoFlash(captureBuilder); 

      int rotation = activity.getWindowManager().getDefaultDisplay().getRotation(); 
      captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation)); 

      CameraCaptureSession.CaptureCallback CaptureCallback 
        = new CameraCaptureSession.CaptureCallback() { 

       @Override 
       public void onCaptureCompleted(@NonNull CameraCaptureSession session, 
               @NonNull CaptureRequest request, 
               @NonNull TotalCaptureResult result) { 
        showToast("Saved: " + mFile); 
        Log.d(TAG, mFile.toString()); 
        unlockFocus(); 
       } 
      }; 

      mCaptureSession.stopRepeating(); 
      mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } 
    } 

    private int getOrientation(int rotation) { 
     return (ORIENTATIONS.get(rotation) + mSensorOrientation + 270) % 360; 
    } 

    private void unlockFocus() { 
     try { 
      mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 
        CameraMetadata.CONTROL_AF_TRIGGER_CANCEL); 
      setAutoFlash(mPreviewRequestBuilder); 
      mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, 
        mBackgroundHandler); 
      mState = STATE_PREVIEW; 
      mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, 
        mBackgroundHandler); 
     } catch (CameraAccessException e) { 
      e.printStackTrace(); 
     } 
    } 

    @Override 
    public void onClick(View view) { 
     switch (view.getId()) { 
      case R.id.picture: { 
       takePicture(); 
       break; 
      } 

     } 
    } 

    private void setAutoFlash(CaptureRequest.Builder requestBuilder) { 
     if (mFlashSupported) { 
      requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, 
        CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH); 
     } 
    } 

    private static class ImageSaver implements Runnable { 

     private final Image mImage; 
     private final File mFile; 

     public ImageSaver(Image image, File file) { 
      mImage = image; 
      mFile = file; 
     } 

     @Override 
     public void run() { 
      ByteBuffer buffer = mImage.getPlanes()[0].getBuffer(); 
      byte[] bytes = new byte[buffer.remaining()]; 
      buffer.get(bytes); 
      FileOutputStream output = null; 
      try { 
       output = new FileOutputStream(mFile); 
       output.write(bytes); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } finally { 
       mImage.close(); 
       if (null != output) { 
        try { 
         output.close(); 
        } catch (IOException e) { 
         e.printStackTrace(); 
        } 
       } 
      } 
     } 

    } 

    static class CompareSizesByArea implements Comparator<Size> { 

     @Override 
     public int compare(Size lhs, Size rhs) { 

      return Long.signum((long) lhs.getWidth() * lhs.getHeight() - 
        (long) rhs.getWidth() * rhs.getHeight()); 
     } 

    } 

} 

Answer 1

Es ist wie die Mathematik in Ihrer GetOrientation Funktion sieht wahrscheinlich falsch ist.

Siehe den Beispielcode für die JPEG_ORIENTATION Dokumentation:

private int getJpegOrientation(CameraCharacteristics c, int deviceOrientation) { 
    if (deviceOrientation == android.view.OrientationEventListener.ORIENTATION_UNKNOWN) return 0; 
    int sensorOrientation = c.get(CameraCharacteristics.SENSOR_ORIENTATION); 

    // Round device orientation to a multiple of 90 
    deviceOrientation = (deviceOrientation + 45)/90 * 90; 

    // Reverse device orientation for front-facing cameras 
    boolean facingFront = c.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT; 
    if (facingFront) deviceOrientation = -deviceOrientation; 

    // Calculate desired JPEG orientation relative to camera orientation to make 
    // the image upright relative to the device orientation 
    int jpegOrientation = (sensorOrientation + deviceOrientation + 360) % 360; 

    return jpegOrientation; 
} 

Die ungeradee Mapping in Ihrer ORIENTIERUNG Tabelle macht es nicht einfach, den Code zu lesen, um sicherzustellen, dass es den Beispielcode übereinstimmt, jedoch.