Android Camera Intent: ¿cómo obtener una foto de tamaño completo?

Estoy usando la intención de lanzar la cámara:

Intent cameraIntent = new Intent( android.provider.MediaStore.ACTION_IMAGE_CAPTURE); getParent().startActivityForResult(cameraIntent, CAMERA_PIC_REQUEST); 

y usando:

 Bitmap thumbnail = (Bitmap) data.getExtras().get("data"); photoImage.setImageBitmap(thumbnail); photoImage.setVisibility(View.VISIBLE); 

Pero es solo una miniatura, ¿cómo obtengo el bitmap completo? Sé que puedo usar mi propia Actividad y usarla:

 Camera.PictureCallback() 

¿Pero hay alguna forma de hacerlo usando Intent?

¡Gracias!

editar:

También probé:

 public void onActivityResult(int requestCode, int resultCode, Intent data) { Uri uri = data.getData(); imageView.setImageURI(uri); } 

Funciona para la foto seleccionada de la galería, pero para la intención de la cámara, data.getData () devuelve nulo.

Para obtener una imagen de cámara de tamaño completo, debe apuntar a la cámara para guardar la imagen en un archivo temporal, como:

  private URI mImageUri; Intent intent = new Intent("android.media.action.IMAGE_CAPTURE"); File photo; try { // place where to store camera taken picture photo = this.createTemporaryFile("picture", ".jpg"); photo.delete(); } catch(Exception e) { Log.v(TAG, "Can't create file to take picture!"); Toast.makeText(activity, "Please check SD card! Image shot is impossible!", 10000); return false; } mImageUri = Uri.fromFile(photo); intent.putExtra(MediaStore.EXTRA_OUTPUT, mImageUri); //start camera intent activity.startActivityForResult(this, intent, MenuShootImage); private File createTemporaryFile(String part, String ext) throws Exception { File tempDir= Environment.getExternalStorageDirectory(); tempDir=new File(tempDir.getAbsolutePath()+"/.temp/"); if(!tempDir.exists()) { tempDir.mkdirs(); } return File.createTempFile(part, ext, tempDir); } 

Luego, una vez que la intención de captura de la imagen terminó de funcionar, solo toma tu foto de la imageUri usando el siguiente código:

 public void grabImage(ImageView imageView) { this.getContentResolver().notifyChange(mImageUri, null); ContentResolver cr = this.getContentResolver(); Bitmap bitmap; try { bitmap = android.provider.MediaStore.Images.Media.getBitmap(cr, mImageUri); imageView.setImageBitmap(bitmap); } catch (Exception e) { Toast.makeText(this, "Failed to load", Toast.LENGTH_SHORT).show(); Log.d(TAG, "Failed to load", e); } } //called after camera intent finished @Override public void onActivityResult(int requestCode, int resultCode, Intent intent) { //MenuShootImage is user defined menu option to shoot image if(requestCode==MenuShootImage && resultCode==RESULT_OK) { ImageView imageView; //... some code to inflate/create/find appropriate ImageView to place grabbed image this.grabImage(imageView); } super.onActivityResult(requestCode, resultCode, intent); } 

El código de la PS necesita ser revisado con respecto a la nueva restricción de seguridad aplicada en Android M – FileProvider : mImageUri debe estar empaquetado con FileProvider

Abra la cámara y guarde la imagen en algún directorio específico

 private String pictureImagePath = ""; private void openBackCamera() { String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); String imageFileName = timeStamp + ".jpg"; File storageDir = Environment.getExternalStoragePublicDirectory( Environment.DIRECTORY_PICTURES); pictureImagePath = storageDir.getAbsolutePath() + "/" + imageFileName; File file = new File(pictureImagePath); Uri outputFileUri = Uri.fromFile(file); Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri); startActivityForResult(cameraIntent, 1); } 

Manejar Imagen

 protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == 1) { File imgFile = new File(pictureImagePath); if(imgFile.exists()){ Bitmap myBitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath()); ImageView myImage = (ImageView) findViewById(R.id.imageviewTest); myImage.setImageBitmap(myBitmap); } } } 

Aunque esta es una pregunta antigua y tiene una respuesta aceptada,
Me gustaría compartir mi solución.
En este caso, no es necesario crear un archivo temporal.
Además creamos un selector que ofrece al usuario ambos: tomar una foto con la cámara o elegir una existente de una galería.

  Intent galleryIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI); Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); Intent chooser = new Intent(Intent.ACTION_CHOOSER); chooser.putExtra(Intent.EXTRA_INTENT, galleryIntent); chooser.putExtra(Intent.EXTRA_TITLE, getString(R.string.chooseaction)); Intent[] intentArray = {cameraIntent}; chooser.putExtra(Intent.EXTRA_INITIAL_INTENTS, intentArray); startActivityForResult(chooser, RESULT_LOAD_IMAGE); 

y aquí estamos recuperando resultados:

 @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { // todo use appropriate resultCode in your case if (requestCode == RESULT_LOAD_IMAGE && resultCode == FragmentActivity.RESULT_OK) { if (data.getData() != null) { // this case will occur in case of picking image from the Gallery, // but not when taking picture with a camera try { Bitmap bitmap = MediaStore.Images.Media.getBitmap(getActivity().getContentResolver(), data.getData()); // do whatever you want with the Bitmap .... } catch (IOException e) { e.printStackTrace(); } } else { // this case will occur when taking a picture with a camera Bitmap bitmap = null; Cursor cursor = getActivity().getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, new String[]{MediaStore.Images.Media.DATA, MediaStore.Images.Media.DATE_ADDED, MediaStore.Images.ImageColumns.ORIENTATION}, MediaStore.Images.Media.DATE_ADDED, null, "date_added DESC"); if (cursor != null && cursor.moveToFirst()) { Uri uri = Uri.parse(cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA))); String photoPath = uri.toString(); cursor.close(); if (photoPath != null) { bitmap = BitmapFactory.decodeFile(photoPath); } } if (bitmap == null) { // for safety reasons you can // use thumbnail if not retrieved full sized image bitmap = (Bitmap) data.getExtras().get("data"); } // do whatever you want with the Bitmap .... } super.onActivityResult(requestCode, resultCode, data); } } 

También utilicé la respuesta de Vicky, pero tuve que guardar el uri en un paquete para evitar la pérdida del cambio de orientación. Entonces, si no obtiene un resultado de su intención después de inclinar el dispositivo, es posible que su uri no haya sobrevivido al cambio de orientación.

 static final int CAMERA_CAPTURE_REQUEST = 1; static final String ARG_CURRENT_PIC_URI = "CURRENT_PIC_URI"; String pictureImagePath = folderName + "/" + imageFileName; File file = new File(Environment.getExternalStorageDirectory(), pictureImagePath); Uri outputFileUri = Uri.fromFile(file); mCurrentPicUri = outputFileUri.getPath(); Intent cameraIntent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri); startActivityForResult(cameraIntent, CAMERA_CAPTURE_REQUEST); 

Código de resultado de la actividad:

 @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == CAMERA_CAPTURE_REQUEST && resultCode == Activity.RESULT_OK) { File imgFile = new File(mCurrentPicUri); // do something with your image // delete uri mCurrentPicUri = ""; } } 

guarde el uri en el paquete:

 @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); // save uri to bundle outState.putString(ARG_CURRENT_PIC_URI, mCurrentPicUri); } 

recuperarlo de su paquete guardado durante en crear:

 if (bundle.containsKey(ARG_CURRENT_PIC_URI)) mCurrentPicUri = bundle.getString(ARG_CURRENT_PIC_URI); 

Para capturar el máximo tamaño de imagen de la cámara, espero que estos sencillos pasos sean bastante útiles

  public static Camera mCamera; Camera.Parameters parameters = mCamera.getParameters(); parameters.getSupportedPictureSizes(); List supportedSizes = parameters.getSupportedPictureSizes(); mSizePicture1 = supportedSizes.get(0); int cameraSize = supportedSizes.size(); mSizePicture2 = supportedSizes.get(cameraSize - 1); if (mSizePicture1.height < mSizePicture2.height) mSizePicture = supportedSizes.get(cameraSize - 1); else mSizePicture = supportedSizes.get(0); parameters.setPictureSize(mSizePicture.width, mSizePicture.height); 

Aquí, se toma el tamaño admitido de cada dispositivo móvil, desde ese tamaño máximo que se fija como tamaño de imagen para capturar.

No use en los datos de onActivityResult . Me llevó muchas horas probar diferentes soluciones. Una cámara guarda una imagen (incluso si no establece permisos para la lectura de la cámara y la tarjeta en AndroidManifest), pero entonces onActivityResult devuelve data == null y MediaStore devuelve una ruta incorrecta. En estas soluciones simplemente obtienes la última imagen de galería, no tu foto.

 private Uri photoUri; @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); ... } @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (requestCode == CAMERA_RESULT) { if (resultCode == RESULT_OK) { if (photoUri != null) { image.setImageURI(photoUri); } } } } private void showCamera() { Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); if (intent.resolveActivity(getContext().getPackageManager()) != null) { File file = null; try { file = createImageFile(); } catch (IOException e) { e.printStackTrace(); } photoUri = null; if (file != null) { photoUri = Uri.fromFile(file); intent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri); startActivityForResult(intent, CAMERA_REQUEST); } } } private File createImageFile() throws IOException { // Create an image file name String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); File storageDir = getContext().getExternalFilesDir(Environment.DIRECTORY_PICTURES); // File storageDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES); return File.createTempFile(timeStamp, ".jpg", storageDir); }