Obtenga / elija una imagen de la aplicación de Galería incorporada de Android mediante progtwigción

Estoy intentando abrir una imagen / imagen en la aplicación incorporada de la Galería desde dentro de mi aplicación.

Tengo un URI de la imagen (la imagen se encuentra en la tarjeta SD).

¿Tienes alguna sugerencia?

Esta es una solución completa. Acabo de actualizar este código de ejemplo con la información proporcionada en la respuesta a continuación por @mad. También consulte la solución a continuación de @Khobaib que explica cómo tratar las imágenes de picasa.

Actualizar

Acabo de revisar mi respuesta original y creé un proyecto simple de Android Studio que puede finalizar desde github e importar directamente en su sistema.

https://github.com/hanscappelle/SO-2169649

(tenga en cuenta que la selección de archivos múltiples todavía necesita trabajo)

Selección de una sola imagen

Con soporte para imágenes de exploradores de archivos gracias al usuario loco.

public class BrowsePictureActivity extends Activity { // this is the action code we use in our intent, // this way we know we're looking at the response from our own action private static final int SELECT_PICTURE = 1; private String selectedImagePath; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); findViewById(R.id.Button01) .setOnClickListener(new OnClickListener() { public void onClick(View arg0) { // in onCreate or any event where your want the user to // select a file Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); startActivityForResult(Intent.createChooser(intent, "Select Picture"), SELECT_PICTURE); } }); } public void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == RESULT_OK) { if (requestCode == SELECT_PICTURE) { Uri selectedImageUri = data.getData(); selectedImagePath = getPath(selectedImageUri); } } } /** * helper to retrieve the path of an image URI */ public String getPath(Uri uri) { // just some safety built in if( uri == null ) { // TODO perform some logging or show user feedback return null; } // try to retrieve the image from the media store first // this will only work for images selected from gallery String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = managedQuery(uri, projection, null, null, null); if( cursor != null ){ int column_index = cursor .getColumnIndexOrThrow(MediaStore.Images.Media.DATA); cursor.moveToFirst(); String path = cursor.getString(column_index); cursor.close(); return path; } // this is our fallback here return uri.getPath(); } } 

Seleccionar múltiples imágenes

Como alguien solicitó esa información en un comentario y es mejor recostackr información.

Establezca un parámetro adicional EXTRA_ALLOW_MULTIPLE en la intención:

 intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true); 

Y en la comprobación de gestión de resultados para ese parámetro:

 if (Intent.ACTION_SEND_MULTIPLE.equals(data.getAction())) && Intent.hasExtra(Intent.EXTRA_STREAM)) { // retrieve a collection of selected images ArrayList list = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM); // iterate over these images if( list != null ) { for (Parcelable parcel : list) { Uri uri = (Uri) parcel; // TODO handle the images one by one here } } } 

Tenga en cuenta que esto solo es compatible con el nivel de API 18+.

Aquí hay una actualización del código fino que hcpl publicó. pero esto funciona con OI File Manager, Astro File Manager Y la galería de medios también (probado). así que supongo que funcionará con cada administrador de archivos (¿hay muchos más que los mencionados?). hizo algunas correcciones al código que escribió.

 public class BrowsePicture extends Activity { //YOU CAN EDIT THIS TO WHATEVER YOU WANT private static final int SELECT_PICTURE = 1; private String selectedImagePath; //ADDED private String filemanagerstring; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ((Button) findViewById(R.id.Button01)) .setOnClickListener(new OnClickListener() { public void onClick(View arg0) { // in onCreate or any event where your want the user to // select a file Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); startActivityForResult(Intent.createChooser(intent, "Select Picture"), SELECT_PICTURE); } }); } //UPDATED public void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == RESULT_OK) { if (requestCode == SELECT_PICTURE) { Uri selectedImageUri = data.getData(); //OI FILE Manager filemanagerstring = selectedImageUri.getPath(); //MEDIA GALLERY selectedImagePath = getPath(selectedImageUri); //DEBUG PURPOSE - you can delete this if you want if(selectedImagePath!=null) System.out.println(selectedImagePath); else System.out.println("selectedImagePath is null"); if(filemanagerstring!=null) System.out.println(filemanagerstring); else System.out.println("filemanagerstring is null"); //NOW WE HAVE OUR WANTED STRING if(selectedImagePath!=null) System.out.println("selectedImagePath is the right one for you!"); else System.out.println("filemanagerstring is the right one for you!"); } } } //UPDATED! public String getPath(Uri uri) { String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = managedQuery(uri, projection, null, null, null); if(cursor!=null) { //HERE YOU WILL GET A NULLPOINTER IF CURSOR IS NULL //THIS CAN BE, IF YOU USED OI FILE MANAGER FOR PICKING THE MEDIA int column_index = cursor .getColumnIndexOrThrow(MediaStore.Images.Media.DATA); cursor.moveToFirst(); return cursor.getString(column_index); } else return null; } 

Los métodos de hcpl funcionan perfectamente antes de KitKat, pero no funcionan con la API DocumentsProvider. Para eso, simplemente siga el tutorial oficial de Android para proveedores de documentos: https://developer.android.com/guide/topics/providers/document-provider.html -> abra un documento, sección Bitmap.

Simplemente usé el código de hcpl y lo extendí: si el archivo con la ruta recuperada arroja una excepción, llamo a esta función:

 private Bitmap getBitmapFromUri(Uri uri) throws IOException { ParcelFileDescriptor parcelFileDescriptor = getContentResolver().openFileDescriptor(uri, "r"); FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor(); Bitmap image = BitmapFactory.decodeFileDescriptor(fileDescriptor); parcelFileDescriptor.close(); return image; } 

Probado en Nexus 5.

base con el código anterior, reflejé el código como a continuación, puede ser que sea más adecuado:

 public String getPath(Uri uri) { String selectedImagePath; //1:MEDIA GALLERY --- query from MediaStore.Images.Media.DATA String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = managedQuery(uri, projection, null, null, null); if(cursor != null){ int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); cursor.moveToFirst(); selectedImagePath = cursor.getString(column_index); }else{ selectedImagePath = null; } if(selectedImagePath == null){ //2:OI FILE Manager --- call method: uri.getPath() selectedImagePath = uri.getPath(); } return selectedImagePath; } 

Revisé la solución de @hcpl y @mad. La solución de hcpl es compatible con la imagen local de la galería y Mad proporcionó una mejor solución además de eso: también ayuda a cargar la imagen de OI / Astro / Dropbox. Pero en mi aplicación, mientras trabajaba en la biblioteca de picasa que ahora está integrada en Android Gallery, ambas soluciones fallan.

Busqué y analicé un poco y finalmente obtuve una solución mejor y más elegante que supera esta limitación. Gracias a Dimitar Darazhanski por su blog, que me ayudó en este caso, lo modifiqué un poco para que sea más fácil de entender. Aquí está mi solución va –

 public class BrowsePicture extends Activity { //YOU CAN EDIT THIS TO WHATEVER YOU WANT private static final int SELECT_PICTURE = 1; private String selectedImagePath; //ADDED private String filemanagerstring; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ((Button) findViewById(R.id.Button01)) .setOnClickListener(new OnClickListener() { public void onClick(View arg0) { // in onCreate or any event where your want the user to // select a file Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); startActivityForResult(Intent.createChooser(intent, "Select Picture"), SELECT_PICTURE); } }); } public void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == RESULT_OK) { if (requestCode == SELECT_PICTURE) { Uri selectedImageUri = data.getData(); Log.d("URI VAL", "selectedImageUri = " + selectedImageUri.toString()); selectedImagePath = getPath(selectedImageUri); if(selectedImagePath!=null){ // IF LOCAL IMAGE, NO MATTER IF ITS DIRECTLY FROM GALLERY (EXCEPT PICASSA ALBUM), // OR OI/ASTRO FILE MANAGER. EVEN DROPBOX IS SUPPORTED BY THIS BECAUSE DROPBOX DOWNLOAD THE IMAGE // IN THIS FORM - file:///storage/emulated/0/Android/data/com.dropbox.android/... System.out.println("local image"); } else{ System.out.println("picasa image!"); loadPicasaImageFromGallery(selectedImageUri); } } } } // NEW METHOD FOR PICASA IMAGE LOAD private void loadPicasaImageFromGallery(final Uri uri) { String[] projection = { MediaColumns.DATA, MediaColumns.DISPLAY_NAME }; Cursor cursor = getContentResolver().query(uri, projection, null, null, null); if(cursor != null) { cursor.moveToFirst(); int columnIndex = cursor.getColumnIndex(MediaColumns.DISPLAY_NAME); if (columnIndex != -1) { new Thread(new Runnable() { // NEW THREAD BECAUSE NETWORK REQUEST WILL BE MADE THAT WILL BE A LONG PROCESS & BLOCK UI // IF CALLED IN UI THREAD public void run() { try { Bitmap bitmap = android.provider.MediaStore.Images.Media.getBitmap(getContentResolver(), uri); // THIS IS THE BITMAP IMAGE WE ARE LOOKING FOR. } catch (Exception ex) { ex.printStackTrace(); } } }).start(); } } cursor.close(); } public String getPath(Uri uri) { String[] projection = { MediaColumns.DATA}; Cursor cursor = getContentResolver().query(uri, projection, null, null, null); if(cursor != null) { //HERE YOU WILL GET A NULLPOINTER IF CURSOR IS NULL //THIS CAN BE, IF YOU USED OI FILE MANAGER FOR PICKING THE MEDIA cursor.moveToFirst(); int columnIndex = cursor.getColumnIndexOrThrow(MediaColumns.DATA); String filePath = cursor.getString(columnIndex); cursor.close(); return filePath; } else return uri.getPath(); // FOR OI/ASTRO/Dropbox etc } 

Compruébalo y avísame si hay algún problema con él. Lo he probado y funciona bien en todos los casos.

Espero que esto ayude a todos.

Suponiendo que tiene una carpeta de imágenes en su directorio de tarjeta SD solo para imágenes.

 Intent intent = new Intent(Intent.ACTION_GET_CONTENT); // tells your intent to get the contents // opens the URI for your image directory on your sdcard intent.setType("file:///sdcard/image/*"); startActivityForResult(intent, 1); 

Luego puede decidir qué desea hacer con el contenido de su actividad.

Este fue un ejemplo para recuperar el nombre de ruta de la imagen, prueba esto con tu código solo para asegurarte de que puedas manejar los resultados que regresan. Puede cambiar el código según sea necesario para ajustarse mejor a sus necesidades.

 protected final void onActivityResult(final int requestCode, final int resultCode, final Intent i) { super.onActivityResult(requestCode, resultCode, i); // this matches the request code in the above call if (requestCode == 1) { Uri _uri = i.getData(); // this will be null if no image was selected... if (_uri != null) { // now we get the path to the image file cursor = getContentResolver().query(_uri, null, null, null, null); cursor.moveToFirst(); String imageFilePath = cursor.getString(0); cursor.close(); } } 

Mi consejo es intentar que la recuperación de imágenes funcione correctamente, creo que el problema es el contenido de acceder a las imágenes en la tarjeta SD. Eche un vistazo a Mostrar imágenes en la tarjeta sd .

Si puede ponerlo en funcionamiento, probablemente con el ejemplo que le proporcione un proveedor correcto, debería ser capaz de encontrar una solución para su código.

Manténganme actualizado actualizando esta pregunta con su progreso. Buena suerte

esta es mi revisión de este tema, reuniendo toda la información aquí, además de otras preguntas relevantes sobre el desbordamiento de la stack. Devuelve imágenes de algún proveedor, mientras maneja las condiciones de falta de memoria y la rotación de la imagen. Es compatible con galería, picasa y administradores de archivos, como buzón. El uso es simple: como entrada, el constructor recibe el solucionador de contenido y el uri. El resultado es el bitmap final.

 /** * Creates resized images without exploding memory. Uses the method described in android * documentation concerning bitmap allocation, which is to subsample the image to a smaller size, * close to some expected size. This is required because the android standard library is unable to * create a reduced size image from an image file using memory comparable to the final size (and * loading a full sized multi-megapixel picture for processing may exceed application memory budget). */ public class UserPicture { static int MAX_WIDTH = 600; static int MAX_HEIGHT = 800; Uri uri; ContentResolver resolver; String path; Matrix orientation; int storedHeight; int storedWidth; public UserPicture(Uri uri, ContentResolver resolver) { this.uri = uri; this.resolver = resolver; } private boolean getInformation() throws IOException { if (getInformationFromMediaDatabase()) return true; if (getInformationFromFileSystem()) return true; return false; } /* Support for gallery apps and remote ("picasa") images */ private boolean getInformationFromMediaDatabase() { String[] fields = { Media.DATA, ImageColumns.ORIENTATION }; Cursor cursor = resolver.query(uri, fields, null, null, null); if (cursor == null) return false; cursor.moveToFirst(); path = cursor.getString(cursor.getColumnIndex(Media.DATA)); int orientation = cursor.getInt(cursor.getColumnIndex(ImageColumns.ORIENTATION)); this.orientation = new Matrix(); this.orientation.setRotate(orientation); cursor.close(); return true; } /* Support for file managers and dropbox */ private boolean getInformationFromFileSystem() throws IOException { path = uri.getPath(); if (path == null) return false; ExifInterface exif = new ExifInterface(path); int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); this.orientation = new Matrix(); switch(orientation) { case ExifInterface.ORIENTATION_NORMAL: /* Identity matrix */ break; case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: this.orientation.setScale(-1, 1); break; case ExifInterface.ORIENTATION_ROTATE_180: this.orientation.setRotate(180); break; case ExifInterface.ORIENTATION_FLIP_VERTICAL: this.orientation.setScale(1, -1); break; case ExifInterface.ORIENTATION_TRANSPOSE: this.orientation.setRotate(90); this.orientation.postScale(-1, 1); break; case ExifInterface.ORIENTATION_ROTATE_90: this.orientation.setRotate(90); break; case ExifInterface.ORIENTATION_TRANSVERSE: this.orientation.setRotate(-90); this.orientation.postScale(-1, 1); break; case ExifInterface.ORIENTATION_ROTATE_270: this.orientation.setRotate(-90); break; } return true; } private boolean getStoredDimensions() throws IOException { InputStream input = resolver.openInputStream(uri); Options options = new Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeStream(resolver.openInputStream(uri), null, options); /* The input stream could be reset instead of closed and reopened if it were possible to reliably wrap the input stream on a buffered stream, but it's not possible because decodeStream() places an upper read limit of 1024 bytes for a reset to be made (it calls mark(1024) on the stream). */ input.close(); if (options.outHeight <= 0 || options.outWidth <= 0) return false; storedHeight = options.outHeight; storedWidth = options.outWidth; return true; } public Bitmap getBitmap() throws IOException { if (!getInformation()) throw new FileNotFoundException(); if (!getStoredDimensions()) throw new InvalidObjectException(null); RectF rect = new RectF(0, 0, storedWidth, storedHeight); orientation.mapRect(rect); int width = (int)rect.width(); int height = (int)rect.height(); int subSample = 1; while (width > MAX_WIDTH || height > MAX_HEIGHT) { width /= 2; height /= 2; subSample *= 2; } if (width == 0 || height == 0) throw new InvalidObjectException(null); Options options = new Options(); options.inSampleSize = subSample; Bitmap subSampled = BitmapFactory.decodeStream(resolver.openInputStream(uri), null, options); Bitmap picture; if (!orientation.isIdentity()) { picture = Bitmap.createBitmap(subSampled, 0, 0, options.outWidth, options.outHeight, orientation, false); subSampled.recycle(); } else picture = subSampled; return picture; } } 

Referencias

Aquí hay dos tutoriales útiles sobre el selector de imágenes con código fuente descargable:

Cómo crear selector de imágenes Android

Cómo seleccionar y recortar imágenes en Android

Sin embargo, la aplicación se verá obligada a cerrarse en algún momento, puede solucionarlo agregando el atributo android: configChanges a la actividad principal en el archivo Manifest, como por ejemplo:

  

Parece que la API de la cámara perdió el control con la orientación, así que esto lo ayudará. 🙂

Debajo del trabajo de solución para 2.3 (Gingerbread) -4.4 (Kitkat), 5.0 (Lollipop) y 6.0 (Marshmallow) también: –

Paso 1 Código para abrir la galería para seleccionar fotos:

 public static final int PICK_IMAGE = 1; private void takePictureFromGalleryOrAnyOtherFolder() { Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); startActivityForResult(Intent.createChooser(intent, "Select Picture"), PICK_IMAGE); } 

Paso 2 Código para obtener datos en el onActivityResult :

  @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (resultCode == Activity.RESULT_OK) { if (requestCode == PICK_IMAGE) { Uri selectedImageUri = data.getData(); String imagePath = getRealPathFromURI(selectedImageUri); //Now you have imagePath do whatever you want to do now }//end of inner if }//end of outer if } public String getRealPathFromURI(Uri contentUri) { //Uri contentUri = Uri.parse(contentURI); String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = null; try { if (Build.VERSION.SDK_INT > 19) { // Will return "image:x*" String wholeID = DocumentsContract.getDocumentId(contentUri); // Split at colon, use second item in the array String id = wholeID.split(":")[1]; // where id is equal to String sel = MediaStore.Images.Media._ID + "=?"; cursor = context.getContentResolver().query( MediaStore.Images.Media.EXTERNAL_CONTENT_URI, projection, sel, new String[] { id }, null); } else { cursor = context.getContentResolver().query(contentUri, projection, null, null, null); } } catch (Exception e) { e.printStackTrace(); } String path = null; try { int column_index = cursor .getColumnIndex(MediaStore.Images.Media.DATA); cursor.moveToFirst(); path = cursor.getString(column_index).toString(); cursor.close(); } catch (NullPointerException e) { e.printStackTrace(); } return path; } 

Para mostrar imágenes y videos, pruebe esto:

  Intent intent = new Intent(); intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI); startActivityForResult(intent, 1); startActivityForResult(Intent.createChooser(intent,"Wybierz plik"), SELECT_FILE); 

Por si acaso eso ayuda; Lo hago para obtener el Bitmap:

 InputStream is = context.getContentResolver().openInputStream(imageUri); Bitmap bitmap = BitmapFactory.decodeStream(is); 

Las respuestas anteriores son correctas. Me enfrenté a un problema diferente cuando en HTC M8 mi aplicación se bloquea al seleccionar una imagen de la galería. Obtengo valor nulo para la ruta de la imagen. Lo arreglé y optimicé con la siguiente solución. en el método onActivityResult

 protected void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if ((requestCode == RESULT_LOAD_IMAGE) && (resultCode == RESULT_OK)) { if (data != null) { Uri selectedImageUri = null; selectedImageUri = data.getData(); String[] filePathColumn = { MediaStore.Images.Media.DATA }; Cursor imageCursor = mainActivity.getContentResolver().query( selectedImageUri, filePathColumn, null, null, null); if (imageCursor == null) { return; } imageCursor.moveToFirst(); int columnIndex = imageCursor.getColumnIndex(filePathColumn[0]); picturePath = imageCursor.getString(columnIndex); if (picturePath == null) { picturePath = selectedImageUri.getPath(); String wholeID = DocumentsContract .getDocumentId(selectedImage); // Split at colon, use second item in the array String id = wholeID.split(":")[1]; String[] column = { MediaStore.Images.Media.DATA }; // where id is equal to String sel = MediaStore.Images.Media._ID + "=?"; Cursor cursor = mainActivity.getContentResolver().query( MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column, sel, new String[] { id }, null); columnIndex = cursor.getColumnIndex(column[0]); if (cursor.moveToFirst()) { picturePath = cursor.getString(columnIndex); } cursor.close(); } picturePathAbs = new File(picturePath).getAbsolutePath(); imageCursor.close(); } 

}

 package com.ImageConvertingDemo; import java.io.BufferedInputStream; import java.io.FileInputStream; import android.app.Activity; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.os.Bundle; import android.util.Log; import android.widget.EditText; import android.widget.ImageView; public class MyActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); EditText tv = (EditText)findViewById(R.id.EditText01); ImageView iv = (ImageView)findViewById(R.id.ImageView01); FileInputStream in; BufferedInputStream buf; try { in = new FileInputStream("/sdcard/smooth.png"); buf = new BufferedInputStream(in,1070); System.out.println("1.................."+buf); byte[] bMapArray= new byte[buf.available()]; tv.setText(bMapArray.toString()); buf.read(bMapArray); Bitmap bMap = BitmapFactory.decodeByteArray(bMapArray, 0, bMapArray.length); /*for (int i = 0; i < bMapArray.length; i++) { System.out.print("bytearray"+bMapArray[i]); }*/ iv.setImageBitmap(bMap); //tv.setText(bMapArray.toString()); //tv.setText(buf.toString()); if (in != null) { in.close(); } if (buf != null) { buf.close(); } } catch (Exception e) { Log.e("Error reading file", e.toString()); } } } 
 public class BrowsePictureActivity extends Activity { // this is the action code we use in our intent, // this way we know we're looking at the response from our own action private static final int SELECT_PICTURE = 1; private String selectedImagePath; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); ((Button) findViewById(R.id.Button01)) .setOnClickListener(new OnClickListener() { public void onClick(View arg0) { // in onCreate or any event where your want the user to // select a file Intent intent = new Intent(); intent.setType("image/*"); intent.setAction(Intent.ACTION_GET_CONTENT); startActivityForResult(Intent.createChooser(intent, "Select Picture"), SELECT_PICTURE); } }); } public void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == RESULT_OK) { if (requestCode == SELECT_PICTURE) { Uri selectedImageUri = data.getData(); selectedImagePath = getPath(selectedImageUri); } } } /** * helper to retrieve the path of an image URI */ public String getPath(Uri uri) { // just some safety built in if( uri == null ) { // TODO perform some logging or show user feedback return null; } // try to retrieve the image from the media store first // this will only work for images selected from gallery String[] projection = { MediaStore.Images.Media.DATA }; Cursor cursor = managedQuery(uri, projection, null, null, null); if( cursor != null ){ int column_index = cursor .getColumnIndexOrThrow(MediaStore.Images.Media.DATA); cursor.moveToFirst(); return cursor.getString(column_index); } // this is our fallback here return uri.getPath(); } } 

Recuperar un tipo específico de archivo

Este ejemplo obtendrá una copia de la imagen.

 static final int REQUEST_IMAGE_GET = 1; public void selectImage() { Intent intent = new Intent(Intent.ACTION_GET_CONTENT); intent.setType("image/*"); if (intent.resolveActivity(getPackageManager()) != null) { startActivityForResult(intent, REQUEST_IMAGE_GET); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_GET && resultCode == RESULT_OK) { Bitmap thumbnail = data.getParcelable("data"); Uri fullPhotoUri = data.getData(); // Do work with photo saved at fullPhotoUri ... } } 

Abra un tipo específico de archivo

Cuando se ejecuta en 4.4 o superior, solicita abrir un archivo administrado por otra aplicación

 static final int REQUEST_IMAGE_OPEN = 1; public void selectImage() { Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); intent.setType("image/*"); intent.addCategory(Intent.CATEGORY_OPENABLE); // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test. startActivityForResult(intent, REQUEST_IMAGE_OPEN); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_IMAGE_OPEN && resultCode == RESULT_OK) { Uri fullPhotoUri = data.getData(); // Do work with full size photo saved at fullPhotoUri ... } } 

Fuente original

Adicional a las respuestas anteriores, si tiene problemas para obtener la ruta correcta (como AndroZip) puede usar esto:

  public String getPath(Uri uri ,ContentResolver contentResolver) { String[] projection = { MediaStore.MediaColumns.DATA}; Cursor cursor; try{ cursor = contentResolver.query(uri, projection, null, null, null); } catch (SecurityException e){ String path = uri.getPath(); String result = tryToGetStoragePath(path); return result; } if(cursor != null) { //HERE YOU WILL GET A NULLPOINTER IF CURSOR IS NULL //THIS CAN BE, IF YOU USED OI FILE MANAGER FOR PICKING THE MEDIA cursor.moveToFirst(); int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA); String filePath = cursor.getString(columnIndex); cursor.close(); return filePath; } else return uri.getPath(); // FOR OI/ASTRO/Dropbox etc } private String tryToGetStoragePath(String path) { int actualPathStart = path.indexOf("//storage"); String result = path; if(actualPathStart!= -1 && actualPathStart< path.length()) result = path.substring(actualPathStart+1 , path.length()); return result; } 

Encuentre la respuesta para seleccionar una sola imagen de la galería

 import android.app.Activity; import android.net.Uri; import android.content.Intent; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.ImageView; import android.widget.TextView; import java.io.ByteArrayOutputStream; import java.io.FileNotFoundException; import java.io.InputStream; public class PickImage extends Activity { Button btnOpen, btnGet, btnPick; TextView textInfo1, textInfo2; ImageView imageView; private static final int RQS_OPEN_IMAGE = 1; private static final int RQS_GET_IMAGE = 2; private static final int RQS_PICK_IMAGE = 3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.image_pick); btnOpen = (Button)findViewById(R.id.open); btnGet = (Button)findViewById(R.id.get); btnPick = (Button)findViewById(R.id.pick); textInfo1 = (TextView)findViewById(R.id.info1); textInfo2 = (TextView)findViewById(R.id.info2); imageView = (ImageView) findViewById(R.id.image); btnOpen.setOnClickListener(btnOpenOnClickListener); btnGet.setOnClickListener(btnGetOnClickListener); btnPick.setOnClickListener(btnPickOnClickListener); } View.OnClickListener btnOpenOnClickListener = new View.OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(); intent.setAction(Intent.ACTION_OPEN_DOCUMENT); intent.addCategory(Intent.CATEGORY_OPENABLE); intent.setType("image/*"); startActivityForResult(intent, RQS_OPEN_IMAGE); } }; View.OnClickListener btnGetOnClickListener = new View.OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(); intent.setAction(Intent.ACTION_GET_CONTENT); intent.addCategory(Intent.CATEGORY_OPENABLE); intent.setType("image/*"); startActivityForResult(intent, RQS_OPEN_IMAGE); } }; View.OnClickListener btnPickOnClickListener = new View.OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI); startActivityForResult(intent, RQS_PICK_IMAGE); } }; @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (resultCode == Activity.RESULT_OK) { if (requestCode == RQS_OPEN_IMAGE || requestCode == RQS_GET_IMAGE || requestCode == RQS_PICK_IMAGE) { imageView.setImageBitmap(null); textInfo1.setText(""); textInfo2.setText(""); Uri mediaUri = data.getData(); textInfo1.setText(mediaUri.toString()); String mediaPath = mediaUri.getPath(); textInfo2.setText(mediaPath); //display the image try { InputStream inputStream = getBaseContext().getContentResolver().openInputStream(mediaUri); Bitmap bm = BitmapFactory.decodeStream(inputStream); ByteArrayOutputStream stream = new ByteArrayOutputStream(); byte[] byteArray = stream.toByteArray(); imageView.setImageBitmap(bm); } catch (FileNotFoundException e) { e.printStackTrace(); } } } } } 

La forma más rápida de abrir la imagen desde la galería o la cámara.

Referencia original: obtener imagen de la galería en Android programáticamente

El siguiente método recibirá la imagen de la galería o cámara y se mostrará en un ImageView. La imagen seleccionada se almacenará internamente.

código para xml

       

Clase JAVA

 import android.content.Intent; import android.graphics.Bitmap; import android.media.MediaScannerConnection; import android.os.Environment; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.ImageView; import android.widget.Toast; import com.androidquery.AQuery; import org.json.JSONException; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.util.Calendar; import java.util.HashMap; public class MainActivity extends AppCompatActivity implements AsyncTaskCompleteListener{ private ParseContent parseContent; private Button btn; private ImageView imageview; private static final String IMAGE_DIRECTORY = "/demonuts_upload_camera"; private final int CAMERA = 1; private AQuery aQuery; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); parseContent = new ParseContent(this); aQuery = new AQuery(this); btn = (Button) findViewById(R.id.btn); imageview = (ImageView) findViewById(R.id.iv); btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); startActivityForResult(intent, CAMERA); } }); } @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { super.onActivityResult(requestCode, resultCode, data); if (resultCode == this.RESULT_CANCELED) { return; } if (requestCode == CAMERA) { Bitmap thumbnail = (Bitmap) data.getExtras().get("data"); String path = saveImage(thumbnail); try { uploadImageToServer(path); } catch (IOException e) { e.printStackTrace(); } catch (JSONException e) { e.printStackTrace(); } } } private void uploadImageToServer(final String path) throws IOException, JSONException { if (!AndyUtils.isNetworkAvailable(MainActivity.this)) { Toast.makeText(MainActivity.this, "Internet is required!", Toast.LENGTH_SHORT).show(); return; } HashMap map = new HashMap(); map.put("url", "https://demonuts.com/Demonuts/JsonTest/Tennis/uploadfile.php"); map.put("filename", path); new MultiPartRequester(this, map, CAMERA, this); AndyUtils.showSimpleProgressDialog(this); } @Override public void onTaskCompleted(String response, int serviceCode) { AndyUtils.removeSimpleProgressDialog(); Log.d("res", response.toString()); switch (serviceCode) { case CAMERA: if (parseContent.isSuccess(response)) { String url = parseContent.getURL(response); aQuery.id(imageview).image(url); } } } public String saveImage(Bitmap myBitmap) { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); myBitmap.compress(Bitmap.CompressFormat.JPEG, 90, bytes); File wallpaperDirectory = new File( Environment.getExternalStorageDirectory() + IMAGE_DIRECTORY); // have the object build the directory structure, if needed. if (!wallpaperDirectory.exists()) { wallpaperDirectory.mkdirs(); } try { File f = new File(wallpaperDirectory, Calendar.getInstance() .getTimeInMillis() + ".jpg"); f.createNewFile(); FileOutputStream fo = new FileOutputStream(f); fo.write(bytes.toByteArray()); MediaScannerConnection.scanFile(this, new String[]{f.getPath()}, new String[]{"image/jpeg"}, null); fo.close(); Log.d("TAG", "File Saved::--->" + f.getAbsolutePath()); return f.getAbsolutePath(); } catch (IOException e1) { e1.printStackTrace(); } return ""; } }