picture - Obtener la ruta de la imagen capturada en Android usando la intención de la cámara

onactivityresult camera android

Question

He intentado obtener la ruta de la imagen capturada para eliminar la imagen, he encontrado muchas respuestas en Stackoverflow pero ninguna de ellas me funciona, recibí la siguiente respuesta

private String getLastImagePath() {
        final String[] imageColumns = { MediaStore.Images.Media._ID,
                MediaStore.Images.Media.DATA };
        final String imageOrderBy = MediaStore.Images.Media._ID + " DESC";
        Cursor imageCursor = POS.this.getContentResolver().query(
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI, imageColumns,
                null, null, imageOrderBy);
        if (imageCursor.moveToFirst()) {
            // int id = imageCursor.getInt(imageCursor
            // .getColumnIndex(MediaStore.Images.Media._ID));
            String fullPath = imageCursor.getString(imageCursor
                    .getColumnIndex(MediaStore.Images.Media.DATA));
            return fullPath;
        } else {
            return "";
        }
    }

pero este código funciona en la pestaña de Samsung pero no funciona en la pestaña lenovo y en la pestaña i-ball. Entonces, ¿alguien puede ayudarme a encontrar otra solución para hacer lo mismo? Cualquier ayuda será apreciada. Gracias.

Este es mi Rendimiento de actividad

if (requestCode == CmsInter.CAMERA_REQUEST && resultCode == RESULT_OK) {
            //Bitmap photo = null;
            //photo = (Bitmap) data.getExtras().get("data");

            String txt = "";
            if (im != null) {
                String result = "";
                //im.setImageBitmap(photo);
                im.setTag("2");
                int index = im.getId();
                String path = getLastImagePath();
                try {
                    bitmap1 = BitmapFactory.decodeFile(path, options);
                    bitmap = Bitmap
                            .createScaledBitmap(bitmap1, 512, 400, false);
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
                    byte[] bytData = baos.toByteArray();
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    result = Base64.encode(bytData);
                    bytData = null;
                } catch (OutOfMemoryError ooM) {
                    System.out.println("OutOfMemory Exception----->" + ooM);
                    bitmap1.recycle();
                    bitmap.recycle();

                } finally {
                    bitmap1.recycle();
                    bitmap.recycle();
                }
}

Answer 1

Aquí actualicé el código de muestra en Kotlin. Tenga en cuenta que en Nougat y la versión anterior, Uri.fromFile(file) no funciona y bloquea la aplicación por la necesidad de implementar FileProvider, que es la forma más segura de enviar archivos desde el intento. Para implementar esto, consulte esta answer o este article

private fun takePhotoFromCamera() {
        val isDeviceSupportCamera: Boolean = this.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)
        if (isDeviceSupportCamera) {
            val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)

            if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
                file = File(getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS + "/attachments")!!.path,
                        System.currentTimeMillis().toString() + ".jpg")
//            fileUri = Uri.fromFile(file)
                fileUri = FileProvider.getUriForFile(this, this.applicationContext.packageName + ".provider", file!!)
                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri)
                if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP) {
                    takePictureIntent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
                }
                startActivityForResult(takePictureIntent, Constants.REQUEST_CODE_IMAGE_CAPTURE)
            }

        } else {
            Toast.makeText(this, this.getString(R.string.camera_not_supported), Toast.LENGTH_SHORT).show()
        }
    }

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (resultCode == Activity.RESULT_OK) {
             if(requestCode == Constants.REQUEST_CODE_IMAGE_CAPTURE) {
                realPath = file?.path
                 //do what ever you want to do
            }
    }
}

Answer 2

Existe una solución para crear archivos (en un directorio de caché externo o en cualquier otro lugar) y colocar el archivo uri de este archivo como salida adicional a la intención de la cámara: esto definirá la ruta donde se almacenará la imagen tomada.

Aquí hay un ejemplo:

File file;
Uri fileUri;
final int RC_TAKE_PHOTO = 1;

    private void takePhoto() {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        file = new File(getActivity().getExternalCacheDir(), 
                String.valueOf(System.currentTimeMillis()) + ".jpg");
        fileUri = Uri.fromFile(file);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, fileUri);
        getActivity().startActivityForResult(intent, RC_TAKE_PHOTO);

    }


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

        if (requestCode == RC_TAKE_PHOTO && resultCode == RESULT_OK) {

                //do whatever you need with taken photo using file or fileUri

            }
        }
    }

Entonces, si ya no necesita el archivo, puede eliminarlo usando file.delete();

Por cierto, los archivos del directorio de caché se eliminarán cuando el usuario borre la caché de la aplicación de la configuración de la aplicación.

Answer 3

Intenta así

Pasar la intención de la cámara como a continuación

Intent intent = new Intent(this);
startActivityForResult(intent, REQ_CAMERA_IMAGE);

Y después de capturar la imagen, escriba un OnActivityResult como se muestra a continuación

protected void onActivityResult(int requestCode, int resultCode, Intent data) {  
    if (requestCode == CAMERA_REQUEST && resultCode == RESULT_OK) {
        Bitmap photo = (Bitmap) data.getExtras().get("data"); 
        imageView.setImageBitmap(photo);
        knop.setVisibility(Button.VISIBLE);


        // CALL THIS METHOD TO GET THE URI FROM THE BITMAP
        Uri tempUri = getImageUri(getApplicationContext(), photo);

        // CALL THIS METHOD TO GET THE ACTUAL PATH
        File finalFile = new File(getRealPathFromURI(tempUri));

        System.out.println(mImageCaptureUri);
    }  
}

public Uri getImageUri(Context inContext, Bitmap inImage) {
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
    String path = Images.Media.insertImage(inContext.getContentResolver(), inImage, "Title", null);
    return Uri.parse(path);
}

public String getRealPathFromURI(Uri uri) {
    Cursor cursor = getContentResolver().query(uri, null, null, null, null); 
    cursor.moveToFirst(); 
    int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA); 
    return cursor.getString(idx); 
}

Y compruebe el registro

Answer 4

La aplicación de la cámara guarda imágenes automáticamente y para obtener esa imagen, podemos hacer lo siguiente:

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

        if (resultCode == Activity.RESULT_OK) {
             Uri imgUri = data.getData();
            String realPath = getRealPathFromURI(imgUri);
        }

}

y el método getRealPathFromUri es:

 public String getRealPathFromURI(Uri uri) {
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);
    cursor.moveToFirst();
    int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
    return cursor.getString(idx);
}

Answer 5

Pruebe este método para obtener la ruta de la imagen original capturada por la cámara.

public String getOriginalImagePath() {
        String[] projection = { MediaStore.Images.Media.DATA };
        Cursor cursor = getActivity().managedQuery(
                MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                projection, null, null, null);
        int column_index_data = cursor
                .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToLast();

        return cursor.getString(column_index_data);
    }

Este método devolverá la ruta de la última imagen capturada por la cámara. Entonces esta ruta sería de imagen original, no de mapa de bits en miniatura .

Answer 6

prueba esto

String[] projection = { MediaStore.Images.Media.DATA };
            @SuppressWarnings("deprecation")
            Cursor cursor = managedQuery(mCapturedImageURI, projection,
                    null, null, null);
            int column_index_data = cursor
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            cursor.moveToFirst();
            image_path = cursor.getString(column_index_data);
            Log.e("path of image from CAMERA......******************.........",
                    image_path + "");

para capturar la imagen:

    String fileName = "temp.jpg";
    ContentValues values = new ContentValues();
    values.put(MediaStore.Images.Media.TITLE, fileName);
    mCapturedImageURI = getContentResolver().insert(
            MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);

    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, mCapturedImageURI);
    values.clear();