selfies - Cámara frontal de Android que toma fotos invertidas

porque las selfies salen al reves samsung

Question

Tengo esta aplicación que se ejecuta en modo retrato y como parte de una actividad tengo un objeto de cámara que se ejecuta como un fragmento.

Tengo la opción de pasar de la cámara frontal a la trasera y cuando tomo fotos con la cámara trasera, todo está bien.

Sin embargo, cuando tomo fotos con la cámara frontal, se invierten 180 grados. Ahora sé que esto probablemente tenga algo que ver con que la orientación esté en modo retrato, pero tenerla en paisaje simplemente mataría la idea de mi aplicación.

¿Hay alguna forma de que esto pueda solucionarse para que la imagen tomada sea la misma que se ve en la vista previa?

        listener = new OrientationEventListener(this.getActivity(),SensorManager.SENSOR_DELAY_NORMAL){

        @Override
        public void onOrientationChanged(int orientation) {
            // TODO Auto-generated method stub
            if (orientation == ORIENTATION_UNKNOWN) return;
             android.hardware.Camera.CameraInfo info =
                    new android.hardware.Camera.CameraInfo();
             android.hardware.Camera.getCameraInfo(mCurrentCamera, info);
             orientation = (orientation + 45) / 90 * 90;
             int rotation = 0;
             if (info.facing == CameraInfo.CAMERA_FACING_FRONT) {
                 rotation = (info.orientation - orientation + 360) % 360;
             } else {  // back-facing camera
                 rotation = (info.orientation + orientation) % 360;
             }
             if (mCamera.getParameters() != null){
             Camera.Parameters mParameters = mCamera.getParameters();

             mParameters.setRotation(rotation);
             mCamera.setParameters(mParameters);
             }
        }

    };
    listener.enable();
    if (listener.canDetectOrientation())
        Log.d("Orientation Possible", "Orientation Possible");

El problema es que, después de intentar tomar una foto, esta cosa se bloquea. Además, si se ejecuta durante un tiempo en modo de vista previa, vuelve a fallar. Probablemente también debería agregar, que en otro método estoy haciendo esto.

   public void switchCamera(Camera camera) {
    setCamera(camera);
    try {
        camera.setPreviewDisplay(mHolder);
    } catch (IOException exception) {
        Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
    }
    Camera.Parameters parameters = camera.getParameters();
    parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);

    requestLayout();


    try{
        camera.setParameters(parameters);
    }
    catch (RuntimeException ex){
        Log.d("Preview", "Failure to set proper parameters");
        //need to improve this method
        if (mSupportedPreviewSizes != null) {
            Camera.Size cs = mSupportedPreviewSizes.get(0);
            parameters.setPreviewSize(cs.width, cs.height);
            camera.setParameters(parameters);
            requestLayout();
            //int tempheight = mPreviewSize.height;
            //mPreviewSize.height = mPreviewSize.width;
            //mPreviewSize.width = tempheight;

        }
    }

Esto se llama cuando se cambia entre cámaras (la parte trasera está orientada hacia el frente y viceversa). ¿Podría esto estar interfiriendo con el oyente del evento de orientación?

Además, al guardar la foto tomada, esto es lo que llamo. Antes solo estaba tomando los datos como un parámetro, pero también intenté que tomara la orientación de la pantalla. El problema es que la orientación de la pantalla es siempre 90, pase lo que pase. Por lo tanto, el mapa de bits siempre se girará 90 grados (lo cual es ideal para tomar fotos con la cámara trasera), pero se invierte cuando se toma con la cámara frontal. ¿Podría implementarse una solución en esta función?

  public static Bitmap MakeSquare(byte[] data, int orientation) {
    int width;
    int height;
    // Rotate photo
    Matrix matrix = new Matrix();
    matrix.postRotate(orientation);
    // Convert ByteArray to Bitmap
    Bitmap bitPic = BitmapFactory.decodeByteArray(data, 0, data.length);
    width = bitPic.getWidth();
    height = bitPic.getHeight();


    // Create new Bitmap out of the old one
    Bitmap bitPicFinal = Bitmap.createBitmap(bitPic, 0, 0, width, height,matrix, true);
    bitPic.recycle();
    int desWidth;
    int desHeight;
    desWidth = bitPicFinal.getWidth();
    desHeight = desWidth;
    Bitmap croppedBitmap = Bitmap.createBitmap(bitPicFinal, 0,bitPicFinal.getHeight() / 2 - bitPicFinal.getWidth() / 2,desWidth, desHeight);
    croppedBitmap = Bitmap.createScaledBitmap(croppedBitmap, 528, 528, true);
    return croppedBitmap;
}

Answer 1

Bien bien. Parece que ya lo tengo cuidado. Utilicé los consejos de este: Android, orientación frontal y posterior de la cámara, paisaje.

Y cambié mi función MakeSquare a esto:

public static Bitmap MakeSquare(byte[] data, int cameraID) {
    int width;
    int height;
    Matrix matrix = new Matrix();
    Camera.CameraInfo info = new Camera.CameraInfo();
    android.hardware.Camera.getCameraInfo(cameraID, info);
    // Convert ByteArray to Bitmap
    Bitmap bitPic = BitmapFactory.decodeByteArray(data, 0, data.length);
    width = bitPic.getWidth();
    height = bitPic.getHeight();

    // Perform matrix rotations/mirrors depending on camera that took the photo
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT)
    {
        float[] mirrorY = { -1, 0, 0, 0, 1, 0, 0, 0, 1};
        Matrix matrixMirrorY = new Matrix();
        matrixMirrorY.setValues(mirrorY);

        matrix.postConcat(matrixMirrorY);
    }

    matrix.postRotate(90);


    // Create new Bitmap out of the old one
    Bitmap bitPicFinal = Bitmap.createBitmap(bitPic, 0, 0, width, height,matrix, true);
    bitPic.recycle();
    int desWidth;
    int desHeight;
    desWidth = bitPicFinal.getWidth();
    desHeight = desWidth;
    Bitmap croppedBitmap = Bitmap.createBitmap(bitPicFinal, 0,bitPicFinal.getHeight() / 2 - bitPicFinal.getWidth() / 2,desWidth, desHeight);
    croppedBitmap = Bitmap.createScaledBitmap(croppedBitmap, 528, 528, true);
    return croppedBitmap;
}

Esto parece funcionar y hacer el truco. Aunque no estoy seguro de que esta sea la mejor manera, estoy contento con ello. Ahora todo lo que tengo que hacer es averiguar por qué no está tomando la relación de aspecto adecuada cuando uso la cámara frontal.

Answer 2

Prueba estos enlaces:

http://developer.android.com/reference/android/hardware/Camera.html#setDisplayOrientation(int )

http://developer.android.com/reference/android/hardware/Camera.Parameters.html#setRotation(int )

Específicamente, aquí hay un fragmento de verborrea del enlace setRotation.

"Si las aplicaciones desean rotar la imagen para que coincida con la orientación de lo que ven los usuarios, deben usar OrientationEventListener y Camera.CameraInfo. El valor de OrientationEventListener es relativo a la orientación natural del dispositivo. CameraInfo.orientation es el ángulo entre la orientación de la cámara y orientación natural del dispositivo. La suma de los dos es el ángulo de rotación de la cámara orientada hacia atrás. La diferencia de los dos es el ángulo de rotación de la cámara frontal . Tenga en cuenta que las imágenes JPEG de las cámaras frontales no se reflejan como en la vista previa monitor."

Utilicé este código como está, no lo modifiqué en absoluto. Mi cámara está mejor ahora, todavía necesita un poco de TLC. Tampoco tengo la funcionalidad frontal.

¡Buena suerte!