Android cómo corregir la orientación de la cámara

Observe cómo la vista de la cámara (NO LA IMAGEN CAPTURADA) se volcó a la izquierda (imagen de arriba), la orientación de la Activity es correcta, pero la vista de la cámara está en mal estado, por favor me ayudan chicos 🙂 gracias.

Aquí está el fichero XML de diseño:

<?xml version="1.0" encoding="utf-8"?>
<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="match_parent"
        android:orientation="vertical" >

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:gravity="center|top"
            android:orientation="vertical" >

            <SurfaceView
                android:id="@+id/camerapreview"
                android:layout_margin="10dp"
                android:layout_width="300dp"
                android:layout_height="300dp" />
        </LinearLayout>
    </LinearLayout>

</LinearLayout>

Y aquí está el código para la actividad:

public class CustomCameraActivity extends Activity implements SurfaceHolder.Callback {

    Camera camera;
    SurfaceView surfaceView;
    SurfaceHolder surfaceHolder;
    boolean previewing = false;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.camera);

        surfaceView = (SurfaceView)findViewById(R.id.camerapreview);
        surfaceHolder = surfaceView.getHolder();
        surfaceHolder.addCallback(this);

    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        if(previewing){
            camera.stopPreview();
            previewing = false;
        }

        if (camera != null){
            try {
                camera.setPreviewDisplay(surfaceHolder);
                camera.startPreview();
                previewing = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        camera = Camera.open();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        camera.stopPreview();
        camera.release();
        camera = null;
        previewing = false;
    }
}
InformationsquelleAutor CENT1PEDE | 2013-11-19

4 Comentarios

  1. 35

    He encontrado la solución aquí. Respuesta por @Ed Jellard.

    sólo tengo que añadir camera.setDisplayOrientation(90); en surfaceCreated(SurfaceHolder holder) método, ahora la pantalla está en el ángulo derecho.

    Android cómo corregir la orientación de la cámara

    ver a la feliz T-REX 🙂

    • No creo que este T-REX es feliz 😛 de todos Modos, me ayudó a mí. Gracias.
    • se ve feliz a mí. 😀
    • pero esta solución no funciona en todos los dispositivos
    • Esto sólo funcionará si la cámara del dispositivo está orientado en un paisaje de la moda. Mientras que esto funcionará para la mayoría, esto no funciona para los dispositivos como el Nexus 5, cuya cámara es inversa paisaje (que había necesidad de establecer la orientación a 180)
    • Esto sólo funcionará en este dispositivo, y de haber girado la imagen en los otros dispositivos. Esta podría ser la solución correcta: captechconsulting.com/blogs/…
  2. 18

    Este problema fue resuelto hace mucho tiempo, pero he encontrado algunas dificultades para poner todas las piezas juntas así que aquí está mi solución final, espero que esto ayude a otros :

    public void startPreview() {
    try {
    Log.i(TAG, "starting preview: " + started);
    //....
    Camera.CameraInfo camInfo = new Camera.CameraInfo();
    Camera.getCameraInfo(cameraIndex, camInfo);
    int cameraRotationOffset = camInfo.orientation;
    //...
    Camera.Parameters parameters = camera.getParameters();
    List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();
    Camera.Size previewSize = null;
    float closestRatio = Float.MAX_VALUE;
    int targetPreviewWidth = isLandscape() ? getWidth() : getHeight();
    int targetPreviewHeight = isLandscape() ? getHeight() : getWidth();
    float targetRatio = targetPreviewWidth / (float) targetPreviewHeight;
    Log.v(TAG, "target size: " + targetPreviewWidth + " /" + targetPreviewHeight + " ratio:" + targetRatio);
    for (Camera.Size candidateSize : previewSizes) {
    float whRatio = candidateSize.width / (float) candidateSize.height;
    if (previewSize == null || Math.abs(targetRatio - whRatio) < Math.abs(targetRatio - closestRatio)) {
    closestRatio = whRatio;
    previewSize = candidateSize;
    }
    }
    int rotation = getWindowManager().getDefaultDisplay().getRotation();
    int degrees = 0;
    switch (rotation) {
    case Surface.ROTATION_0:
    degrees = 0;
    break; //Natural orientation
    case Surface.ROTATION_90:
    degrees = 90;
    break; //Landscape left
    case Surface.ROTATION_180:
    degrees = 180;
    break;//Upside down
    case Surface.ROTATION_270:
    degrees = 270;
    break;//Landscape right
    }
    int displayRotation;
    if (isFrontFacingCam) {
    displayRotation = (cameraRotationOffset + degrees) % 360;
    displayRotation = (360 - displayRotation) % 360; //compensate
    //the
    //mirror
    } else { //back-facing
    displayRotation = (cameraRotationOffset - degrees + 360) % 360;
    }
    Log.v(TAG, "rotation cam /phone = displayRotation: " + cameraRotationOffset + " /" + degrees + " = "
    + displayRotation);
    this.camera.setDisplayOrientation(displayRotation);
    int rotate;
    if (isFrontFacingCam) {
    rotate = (360 + cameraRotationOffset + degrees) % 360;
    } else {
    rotate = (360 + cameraRotationOffset - degrees) % 360;
    }
    Log.v(TAG, "screenshot rotation: " + cameraRotationOffset + " /" + degrees + " = " + rotate);
    Log.v(TAG, "preview size: " + previewSize.width + " /" + previewSize.height);
    parameters.setPreviewSize(previewSize.width, previewSize.height);
    parameters.setRotation(rotate);
    camera.setParameters(parameters);
    camera.setPreviewDisplay(mHolder);
    camera.startPreview();
    Log.d(TAG, "preview started");
    started = true;
    } catch (IOException e) {
    Log.d(TAG, "Error setting camera preview: " + e.getMessage());
    }
    }
    • a dónde puedo llamar el código ?
    • No sé cómo lidiar con las variables. Sería genial si se agrega más información sobre el resto. Hay un montón de red de las variables en el código.
  3. 1

    Hay una propiedad en la clase Camera.CameraInfo nombrado como orientation. Devuelve el entero. Usted puede obtener la orientación actual y, a continuación, cambia en consecuencia.

    Ver este respuesta para el manejo de la orientación y CameraInfo clase.

    Estoy seguro de que esto te ayude.

  4. -3

    La cámara gira automáticamente al girar el teléfono, sin Embargo, si usted quiere que la imagen capturada por la cámara o desde la galería a ser en la orientación correcta, utilice esto :-

    public void rotate(String filePath){
    Bitmap cameraBitmap = null;
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inPurgeable = true;
    bmOptions.inBitmap = cameraBitmap; 
    bmOptions.inMutable = true; 
    cameraBitmap = BitmapFactory.decodeFile(filePath,bmOptions); 
    //Your image file path
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    cameraBitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
    ExifInterface exif = new ExifInterface(filePath);
    float rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);  
    System.out.println(rotation);
    float rotationInDegrees = exifToDegrees(rotation);
    System.out.println(rotationInDegrees);
    Matrix matrix = new Matrix();
    matrix.postRotate(rotationInDegrees);
    Bitmap rotatedBitmap = Bitmap.createBitmap(cameraBitmap , 0, 0, cameraBitmap.getWidth(), cameraBitmap.getHeight(), matrix, true);
    FileOutputStream fos=new FileOutputStream(filePath);
    rotatedBitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);
    fos.write(bos.toByteArray());
    cameraBitmap.recycle();
    System.gc();
    fos.flush();
    fos.close();
    }
    private static float exifToDegrees(float exifOrientation) {        
    if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) { return 90; } 
    else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) {  return 180; } 
    else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) {  return 270; }            
    return 0;    
    } 

Dejar respuesta

Please enter your comment!
Please enter your name here