android - the - Orientación de la cámara en el problema del dispositivo de Samsung

cell phones with the best camera quality

Question

Estoy haciendo clic con éxito en la imagen y guardándola en la tarjeta. Está funcionando perfectamente en todos los dispositivos, pero el problema es que cuando lo estoy probando en el dispositivo Samsung, cuando hago clic en la imagen en el modo vertical, está guardando la imagen de forma predeterminada en el modo horizontal. Pero no estoy haciendo ningún tipo de código rotativo. Entonces por favor ayudame ¿¿Cómo puedo resolverlo??

private void takePicture() {

    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

    try {
        Uri mImageCaptureUri = null;
        String state = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED.equals(state)) {
            mImageCaptureUri = Uri.fromFile(mFileTemp);
        } else {
            mImageCaptureUri = InternalStorageContentProvider.CONTENT_URI;
        }
        intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT,
                mImageCaptureUri);
        intent.putExtra("return-data", true);
        startActivityForResult(intent, REQUEST_CODE_TAKE_PICTURE);
    } catch (ActivityNotFoundException e) {

        Log.d("", "cannot take picture", e);
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {

    if (resultCode != RESULT_OK) {

        return;
    }

    Bitmap bitmap;

    switch (requestCode) {

    case REQUEST_CODE_TAKE_PICTURE:

        startCropImage();
        break;
    case REQUEST_CODE_CROP_IMAGE:

        String path = data.getStringExtra(CropImage.IMAGE_PATH);
        if (path == null) {

            return;
        }

        bitmap = BitmapFactory.decodeFile(mFileTemp.getPath());
        resizedBitmap = ScalingUtilities.createScaledBitmap(bitmap, 320,
                320, ScalingLogic.CROP);
        imgPreview.setImageBitmap(resizedBitmap);
        break;
    }
    super.onActivityResult(requestCode, resultCode, data);
}


private void startCropImage() {

    Intent intent = new Intent(this, CropImage.class);
    intent.putExtra(CropImage.IMAGE_PATH, mFileTemp.getPath());
    intent.putExtra(CropImage.SCALE, true);

    intent.putExtra(CropImage.ASPECT_X, 2);
    intent.putExtra(CropImage.ASPECT_Y, 2);

    startActivityForResult(intent, REQUEST_CODE_CROP_IMAGE);
}

Agregué los siguientes permisos en el manifiesto.

   <uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.hardware.camera.autofocus" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Answer 1

Muchos dispositivos, pero no todos, no guardarán imágenes verticales. Guardarán imágenes de paisajes con un encabezado EXIF ​​que le indicará al visor de imágenes que gire la imagen a vertical. No todos los visualizadores de imagen manejan esto.

Esta es parte de la razón por la que escribí la biblioteca CWAC-Camera , para proporcionar salida de cámara uniforme desde diferentes dispositivos.

El código que uso para esto es una reminiscencia de lo que Haresh señala en su comentario, con algunas diferencias notables:

1. El código de Haresh parece suponer que la cámara estaba en modo vertical; el mío tiene como objetivo manejar cualquier caso.

2. El código de Haresh hace todo el trabajo duro de forma explícita en el hilo principal de la aplicación, incluida la E / S del disco, lo cual es una muy mala idea. El mío es un hilo de fondo.

3. Su código reduce la imagen. Mi suposición es que esto es para ayudar a prevenir errores de falta de memoria, lo cual es definitivamente un desafío aquí. En mi caso, doy a los desarrolladores que utilizan mi biblioteca la opción de especificar un montón grande, para ayudar a asegurar que pueda realizar la rotación del mapa de bits. Eventualmente, moveré este código al NDK, donde las asignaciones de memoria no se cuentan contra el límite del montón de Dalvik.

4. Mi código también es responsable de otros problemas específicos del dispositivo, como voltear la imagen de FFC si es necesario o duplicar la imagen de FFC si así lo solicita el desarrollador.

Sin embargo, mi código está diseñado específicamente para ser utilizado por mi biblioteca, por lo que necesitaría una buena cantidad de trabajo para dividir la lógica en algo que se pudiera usar de forma independiente.

Tenga en cuenta que el enlace a mi código es específicamente al v0.6.9 de la biblioteca. Las versiones más recientes de esta clase pueden existir en el repositorio si está leyendo estos meses después de que escribí esta respuesta. Por el contrario, la clase puede que ya no exista en el master repo, si he movido el código al NDK.

Answer 2

Solucioné mi error, en realidad uso un truco. Tomé el nombre genérico programáticamente, así

 String device_name = Build.MANUFACTURER;

Después de eso lo guardé en el objeto de preferencias compartidas.

 deviceIdPreferences = getSharedPreferences("USER_INFO", Context.MODE_PRIVATE);
    SharedPreferences.Editor   editor = deviceIdPreferences.edit();
    editor.putString("Device_id",deviceId);
    editor.putString("device_name",device_name);
    editor.commit();

Después de eso en el archivo java de destino, extraño el valor de la preferencia compartida.

preferences = this.getSharedPreferences(
            "USER_INFO", Context.MODE_PRIVATE);
    device_name = preferences.getString("device_name", "Empty");

y entonces

    mBitmap = getBitmap(mImagePath);
    if(device_name.equals("samsung")){

            switch (Integer.parseInt(gotOrientation)) {

                case ExifInterface.ORIENTATION_ROTATE_90:
                    mBitmap = Util.rotateImage(mBitmap, 90);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    mBitmap = Util.rotateImage(mBitmap, 90);
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    mBitmap = Util.rotateImage(mBitmap, 90);
                    break;
                default:
                    mBitmap = Util.rotateImage(mBitmap, 90);
                    break;
            }

        }




 private Bitmap getBitmap(String path) {

    Uri uri = getImageUri(path);
    InputStream in = null;
    try {
        in = mContentResolver.openInputStream(uri);

        //Decode image size
        BitmapFactory.Options o = new BitmapFactory.Options();
        o.inJustDecodeBounds = true;

        BitmapFactory.decodeStream(in, null, o);
        in.close();

        int scale = 1;
        if (o.outHeight > IMAGE_MAX_SIZE || o.outWidth > IMAGE_MAX_SIZE) {
            scale = (int) Math.pow(2, (int) Math.round(Math.log(IMAGE_MAX_SIZE / (double) Math.max(o.outHeight, o.outWidth)) / Math.log(0.5)));
        }

        BitmapFactory.Options o2 = new BitmapFactory.Options();
        o2.inSampleSize = scale;
        in = mContentResolver.openInputStream(uri);
        Bitmap b = BitmapFactory.decodeStream(in, null, o2);
        in.close();

        return b;
    } catch (FileNotFoundException e) {
        Log.e(TAG, "file " + path + " not found");
    } catch (IOException e) {
        Log.e(TAG, "file " + path + " not found");
    }
    return null;
}