Estoy creando una aplicación que utiliza la cámara para tomar fotos. Aquí está mi código fuente para hacer esto:

        File file = new File(Environment.getExternalStorageDirectory(),
            imageFileName);
    imageFilePath = file.getPath();
    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
    //Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
    startActivityForResult(intent, ACTIVITY_NATIVE_CAMERA_AQUIRE);

Sobre onActivityResult() método, yo uso BitmapFactory.decodeStream() para recoger la imagen.

Cuando ejecuto mi aplicación en el Nexus one, se ejecuta bien. Pero cuando voy a ejecutar en el Samsung Galaxy S o el HTC Inspire 4G, la imagen de la dirección no es correcta.

  • De captura con el modo de retrato, la imagen real (guardar en la tarjeta SD) siempre gira 90 grados.

La orientación de la cámara problema en Android

Imagen de vista previa después de la inyección ——— Real de la imagen en la tarjeta SD

  • Capturar con el modo de paisaje, todas las cosas son buenas.

La orientación de la cámara problema en Android

Imagen de vista previa después de la inyección ——— Real de la imagen en la tarjeta SD

14 Comentarios

  1. 50

    Hay bastante un par de temas similares y las cuestiones de por aquí. Desde que no estás escribiendo su propia cámara, creo que todo se reduce a esto:

    algunos dispositivos rotar la imagen antes de guardarla, mientras que otros simplemente agregar la orientación de la etiqueta en la foto datos exif.

    Me gustaría recomendar la comprobación de la foto datos exif y buscando especialmente para

    ExifInterface exif = new ExifInterface(SourceFileName);     //Since API Level 5
    String exifOrientation = exif.getAttribute(ExifInterface.TAG_ORIENTATION);

    Ya que la foto se muestre correctamente en su aplicación, no estoy seguro de dónde está el problema, pero esto sin duda se debe establecer en el camino correcto!

    • Esto no parece funcionar en algunos dispositivos, devuelve 0 para todas las orientaciones.. sé que sucede en el Galaxy S Infundir y Sony Xperia Arc, y S II.. cosa Interesante aquí es que cuando estas mismas imágenes seleccionadas de la galería, el proveedor de contenido tiene la orientación correcta de valor.. Alguna idea?
    • aquí sourcefilename en realidad toda la ruta de acceso del archivo
    • Estás en lo correcto. Devuelve 0 para algunos dispositivos, incluyendo DroidX. Actualmente estoy trabajando en una solución. No se si se va a trabajar.
    • Sí, intenté solucionar este (abierto ticket con Android y así sucesivamente) Y creo que he encontrado una solución razonable para manejar ambos teléfonos con una adecuada y defectuosa de la información de orientación. Echa un vistazo a mi respuesta detallada que he publicado a mi propia pregunta aquí; stackoverflow.com/a/8864367/137404
    • He probado esta solución para encontrar. pero es devolver 0 para todas las orientaciones. ¿Tiene usted alguna idea de por qué es devolver 0 para todos los de la orientación.
    • donde poner este código?
    • tiene u tiene la solución, si sí,podría u por favor compartirlo?
    • lo siento bro, esto fue hace tanto tiempo que ni siquiera puedo recordar. Te avisaré si encuentro algo.
    • La razón para esta solución no funciona a veces es un mal «camino» que se utiliza en ExifInterface constructor. Sobre todo en KitKat. Ven aquí, cómo llegar el sendero de la derecha: stackoverflow.com/a/20559175/690777
    • Siempre devuelve 0 (ExifInterface.ORIENTATION_UNDEFINED) en mi Samsung Galaxy S4…
    • Luchó por un tiempo con el método de rotación ya que en algunos dispositivos cuando viradas foto en el modo de retrato simple de rotación hace que la imagen se estira. La solución encontrada fue: code Matrix matrix = new Matrix(); matrix.postTranslate(-width / 2, -height / 2); matrix.postRotate(angle); matrix.postTranslate(width / 2, height / 2);
    • full & respuesta correcta, aquí presentes, stackoverflow.com/questions/6069122/…
    • no funciona en la tablet..

  2. 28

    Acabo encontrado con el mismo problema, y lo utilizó para corregir la orientación:

    public void fixOrientation() {
        if (mBitmap.getWidth() > mBitmap.getHeight()) {
            Matrix matrix = new Matrix();
            matrix.postRotate(90);
            mBitmap = Bitmap.createBitmap(mBitmap , 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
        }
    }

    Si el ancho del mapa de bits es mayor que la altura, la devolución de la imagen está en el paisaje, así que me gire 90 grados.

    La esperanza de que ayuda a cualquier persona con este problema.

    • ¿Y si la imagen del toma en el paisaje? El código todavía gira. Esto no es una respuesta a la pregunta.
    • Mi aplicación de las fuerzas de retrato, de modo que no es un problema. Sólo he incluido aquí una solución alternativa al problema.
    • Pero si la aplicación de las fuerzas retrato usted todavía puede tomar un paisaje de la imagen (ancho > altura) y será girado… Es al menos lo que yo estoy haciendo configuración screenOrientation=»retrato» de todo… cámara puede tomar paisaje de fotos.
    • gracias me salvaste el día
    • full & respuesta correcta, aquí presentes, stackoverflow.com/questions/6069122/…
  3. 21

    Hay dos cosas necesarias:

    1. Vista previa de la cámara necesidad de la misma como su rotación. Establecer esta por camera.setDisplayOrientation(result);

    2. Guardar la imagen capturada como la cámara de vista previa.
      Hacerlo a través de Camera.Parameters.

      int mRotation = getCameraDisplayOrientation();
      
      Camera.Parameters parameters = camera.getParameters();
      
      parameters.setRotation(mRotation); //set rotation to save the picture
      
      camera.setDisplayOrientation(result); //set the rotation for preview camera
      
      camera.setParameters(parameters);

    Espero que ayude.

    • esto es! De la cámara.los parámetros es muy conveniente guardar capturas de pantalla sin la representación de un mapa de bits intermedio
    • Por favor marca este como la respuesta más fácil! Este hacer el trabajo! Muy contento con esta fácil solución
    • Si este fragmento es tomado como lo que es, podríamos decir parameters.setRotation(result), ¿no?
    • Esto asume que usted está usando la Cámara de la clase directamente, no son capaces de especificar las mismas opciones cuando usted está utilizando el ACTION_IMAGE_CAPTURE intención.
    • Muy fácil solución – que funcionó para mí
    • ¿Cuál es el resultado y getCameraDisplayOrientation()?

  4. 10
                int rotate = 0;
                try {
                    File imageFile = new File(sourcepath);
                    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;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                Matrix matrix = new Matrix();
        matrix.postRotate(rotate);
        bitmap = Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
    • sería útil tener alguna explicación de lo que hace el código, y cómo está haciendo las cosas de manera diferente que otras respuestas (la pregunta es, después de todo ya bastante antiguo, y el otro responde, por tanto, probablemente muy maduras).
    • trabajó para mí!!!
  5. 7

    Otra opción es girar el mapa de bits en la pantalla de resultados como este:

    ImageView img=(ImageView)findViewById(R.id.ImageView01);
    Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.refresh);
    //Getting width & height of the given image.
    int w = bmp.getWidth();
    int h = bmp.getHeight();
    //Setting post rotate to 90
    Matrix mtx = new Matrix();
    mtx.postRotate(90);
    //Rotating Bitmap
    Bitmap rotatedBMP = Bitmap.createBitmap(bmp, 0, 0, w, h, mtx, true);
    BitmapDrawable bmd = new BitmapDrawable(rotatedBMP);
    
    img.setImageDrawable(bmd);
    • Este enfoque no funciona, como también gira las imágenes de los dispositivos que se encarga de la orientación correctamente.
    • full & respuesta correcta, aquí presentes, stackoverflow.com/questions/6069122/…
  6. 3

    También tengo este tipo de problema mismo de algún dispositivo:

    private void rotateImage(final String path) {
    Bitmap scaledBitmap = Bitmap.createScaledBitmap(Conasants.bm1, 1000,
    700, true);
    Bitmap rotatedBitmap = null;
    try {
    ExifInterface ei = new ExifInterface(path);
    int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
    ExifInterface.ORIENTATION_NORMAL);
    Matrix matrix = new Matrix();
    switch (orientation) {
    case ExifInterface.ORIENTATION_ROTATE_90:
    matrix.postRotate(90);
    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
    matrix, true);
    break;
    case ExifInterface.ORIENTATION_ROTATE_180:
    matrix.postRotate(180);
    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
    matrix, true);
    break;
    case ExifInterface.ORIENTATION_ROTATE_270:
    matrix.postRotate(270);
    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
    matrix, true);
    break;
    default:
    rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
    matrix, true);
    break;
    }
    } catch (Throwable e) {
    e.printStackTrace();
    }
    cropImage.setImageBitmap(rotatedBitmap);
    rotatedBitmap = null;
    Conasants.bm1 = null;
    }
  7. 1

    Trate de esta manera :
    estática Uri image_uri;
    estática de mapa de bits taken_image=null;

                image_uri=fileUri; //file where image has been saved
    taken_image=BitmapFactory.decodeFile(image_uri.getPath());
    try
    {
    ExifInterface exif = new ExifInterface(image_uri.getPath()); 
    int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
    switch(orientation) {
    case ExifInterface.ORIENTATION_ROTATE_90:
    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
    RotateBitmap(taken_image, 90);
    break;
    case ExifInterface.ORIENTATION_ROTATE_180:
    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
    RotateBitmap(taken_image, 180);
    break;
    case ExifInterface.ORIENTATION_ROTATE_270:
    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
    RotateBitmap(taken_image, 270);
    break;
    case ExifInterface.ORIENTATION_NORMAL:
    taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
    RotateBitmap(taken_image, 0);
    break;
    }
    }
    catch (OutOfMemoryError e)
    {
    Toast.makeText(getActivity(),e+"\"memory exception occured\"",Toast.LENGTH_LONG).show();
    }
    public Bitmap RotateBitmap(Bitmap source, float angle) {
    Matrix matrix = new Matrix();
    matrix.postRotate(angle);
    round_Image = source;
    round_Image = Bitmap.createBitmap(source, 0, 0, source.getWidth(),   source.getHeight(), matrix, true);
    return Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);

    }

  8. 1

    No más la comprobación de la foto datos exif. Ir fácil con Glide.

    Google nos presentó un Cargador de Imágenes de la Biblioteca para Android desarrollado por bumptech nombre Glide como una biblioteca que recomendado por Google. Se ha utilizado en muchos proyectos de código abierto de Google, hasta ahora, incluyendo el Google I/O 2014 oficial de la aplicación.

    Ex : Glide.con(contexto).de carga(uri).en(imageview);

    Para más : https://github.com/bumptech/glide

  9. 1
    public void setCameraPicOrientation(){
    int rotate = 0;
    try {
    File imageFile = new File(mCurrentPhotoPath);
    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;
    }
    } catch (Exception e) {
    e.printStackTrace();
    }
    Matrix matrix = new Matrix();
    matrix.postRotate(rotate);
    int targetW = 640;
    int targetH = 640;
    /* Get the size of the image */
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
    int photoW = bmOptions.outWidth;
    int photoH = bmOptions.outHeight;
    /* Figure out which way needs to be reduced less */
    int scaleFactor = 1;
    if ((targetW > 0) || (targetH > 0)) {
    scaleFactor = Math.min(photoW/targetW, photoH/targetH);
    }
    /* Set bitmap options to scale the image decode target */
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inSampleSize = scaleFactor;
    bmOptions.inPurgeable = true;
    /* Decode the JPEG file into a Bitmap */
    Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
    bitmap= Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
    /* Associate the Bitmap to the ImageView */
    imageView.setImageBitmap(bitmap);
    }

    Espero que esto ayude!! Gracias

  10. 0
        public static  int mOrientation =  1;
    OrientationEventListener myOrientationEventListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    //TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    setContentView(R.layout.takephoto);
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    myOrientationEventListener
    = new OrientationEventListener(getApplicationContext()) {
    @Override
    public void onOrientationChanged(int o) {
    //TODO Auto-generated method stub
    if(!isTablet(getApplicationContext()))
    {
    if(o<=285 && o>=80)
    mOrientation = 2;
    else
    mOrientation = 1;
    }
    else
    {
    if(o<=285 && o>=80)
    mOrientation = 1;
    else
    mOrientation = 2;
    }
    }
    };
    myOrientationEventListener.enable();
    }
    public static boolean isTablet(Context context) {
    return (context.getResources().getConfiguration().screenLayout
    & Configuration.SCREENLAYOUT_SIZE_MASK)
    >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }
    }

    Espero que esto ayude.Gracias!

  11. 0

    Sólo encuentro el mismo problema aquí, el siguiente fragmento de código me funciona:

    private static final String[] CONTENT_ORIENTATION = new String[] {
    MediaStore.Images.ImageColumns.ORIENTATION
    };
    static int getExifOrientation(ContentResolver contentResolver, Uri uri) {
    Cursor cursor = null;
    try {
    cursor = contentResolver.query(uri, CONTENT_ORIENTATION, null, null, null);
    if (cursor == null || !cursor.moveToFirst()) {
    return 0;
    }
    return cursor.getInt(0);
    } catch (RuntimeException ignored) {
    //If the orientation column doesn't exist, assume no rotation.
    return 0;
    } finally {
    if (cursor != null) {
    cursor.close();
    }
    }
    }

    espero que esta ayuda 🙂

  12. 0

    Intente esto en surfaceChanged de devolución de llamada:

    Camera.Parameters parameters=mCamera.getParameters();
    if(this.getResources().getConfiguration().orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
    parameters.setRotation(90);
    }else{
    parameters.setRotation(0);
    }
    mCamera.setParameters(parameters);
    • no funcionó para mí
  13. -1

    El código es funcional para el paisaje y el retrato
    @frontCameraID = variable consiguió el método clásico para mostrar la cámara quería

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    if(holder.getSurface() == null) {
    return;
    }
    try{
    camera.stopPreview();
    } catch (Exception e){
    }
    try{
    int orientation = getDisplayOrientation(frontCameraID);
    Camera.Parameters parameters = camera.getParameters();
    parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
    if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
    parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    }
    parameters.setRotation(rotationPicture);
    camera.setParameters(parameters);
    camera.setDisplayOrientation(orientation);
    camera.startPreview();
    } catch (Exception e) {
    Log.i("ERROR", "Camera error changed: " + e.getMessage());
    }
    }

    Método para obtener orientación y rotación para guardar la imagen y la orientación de la pantalla
    @resultado = orientación en la vista previa de la cámara
    @rotationPicture = rotación necesario para guardar la imagen correctamente

    private int getDisplayOrientation(int cameraId) {
    android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
    android.hardware.Camera.getCameraInfo(cameraId, info);
    int rotation = ((Activity) context).getWindowManager().getDefaultDisplay().getRotation();
    int degrees = 0;
    switch (rotation) {
    case Surface.ROTATION_0: degrees = 0; break;
    case Surface.ROTATION_90: degrees = 90; break;
    case Surface.ROTATION_180: degrees = 180; break;
    case Surface.ROTATION_270: degrees = 270; break;
    }
    int result;
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
    result = (info.orientation + degrees) % 360;
    result = (360 - result) % 360;
    rotationPicture = (360 - result) % 360;
    } else {
    result = (info.orientation - degrees + 360) % 360;
    rotationPicture = result;
    }
    return result;
    }

    Alguien pregunta sobre el código, por favor dígame.

  14. -1

    dos Una línea de soluciones mediante el uso de Picasso y el deslizamiento de la biblioteca

    Después de pasar un montón de tiempo con un montón de soluciones para la rotación de la imagen problema que finalmente he encontrado dos soluciones simples. No necesitamos hacer otros trabajos. Picasso y Glide es un muy potente librería para el manejo de imágenes en su aplicación incluye. Es capaz de leer datos EXIF de la imagen y la auto-gira las imágenes.

    El uso de deslizamiento de la biblioteca https://github.com/bumptech/glide

    Glide.with(this).load("http url or sdcard url").into(imgageView);

    El uso de Picasso biblioteca https://github.com/square/picasso

    Picasso.with(context).load("http url or sdcard url").into(imageView);

Dejar respuesta

Please enter your comment!
Please enter your name here