Obtenir le nom de fichier et le chemin d'accès à partir de l'URI de la mediastore

Juste une simple mise à jour sur la première réponse: mActivity.managedQuery() est maintenant obsolète. J'ai mis à jour le code avec la nouvelle méthode.

private String getRealPathFromURI(Uri contentUri) {
    String[] proj = { MediaStore.Images.Media.DATA };
    CursorLoader loader = new CursorLoader(mContext, contentUri, proj, null, null, null);
    Cursor cursor = loader.loadInBackground();
    int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
    cursor.moveToFirst();
    String result = cursor.getString(column_index);
    cursor.close();
    return result;
}

android dev source

N'essayez pas de trouver une uri dans le système de fichiers, c'est lent pour aller chercher des choses dans la base de données.

Vous pouvez obtenir une image à partir d'un uri en donnant un flux d'entrée à l'usine comme vous donner un fichier à l'usine:

InputStream is = getContentResolver().openInputStream(uri);
Bitmap bitmap = BitmapFactory.decodeStream(is);
is.close();

Bonnes réponses, dont certains que j'ai l'habitude de venir avec mon propre:

- Je obtenir le chemin d'Uri et d'obtenir l'URI de chemins, et Google a du mal à faire la différence donc, pour toute personne qui a le même problème (par exemple, pour obtenir la vignette de l' MediaStore d'une vidéo dont l'emplacement physique que vous avez déjà). L'ancien:

/**
* Gets the corresponding path to a file from the given content://URI
* @param selectedVideoUri The content://URI to find the file path from
* @param contentResolver The content resolver to use to perform the query.
* @return the file path as a string
*/
private String getFilePathFromContentUri(Uri selectedVideoUri,
ContentResolver contentResolver) {
String filePath;
String[] filePathColumn = {MediaColumns.DATA};
Cursor cursor = contentResolver.query(selectedVideoUri, filePathColumn, null, null, null);
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
filePath = cursor.getString(columnIndex);
cursor.close();
return filePath;
}

Ce dernier (ce que je fais pour les vidéos, mais peut aussi être utilisé pour l'Audio ou de Fichiers ou d'autres types de contenu stocké par la substitution MediaStore.Audio (etc) pour MediaStore.Vidéo):

/**
* Gets the MediaStore video ID of a given file on external storage
* @param filePath The path (on external storage) of the file to resolve the ID of
* @param contentResolver The content resolver to use to perform the query.
* @return the video ID as a long
*/
private long getVideoIdFromFilePath(String filePath,
ContentResolver contentResolver) {
long videoId;
Log.d(TAG,"Loading file " + filePath);
//This returns us content://media/external/videos/media (or something like that)
//I pass in "external" because that's the MediaStore's name for the external
//storage on my device (the other possibility is "internal")
Uri videosUri = MediaStore.Video.Media.getContentUri("external");
Log.d(TAG,"videosUri = " + videosUri.toString());
String[] projection = {MediaStore.Video.VideoColumns._ID};
//TODO This will break if we have no matching item in the MediaStore.
Cursor cursor = contentResolver.query(videosUri, projection, MediaStore.Video.VideoColumns.DATA + " LIKE ?", new String[] { filePath }, null);
cursor.moveToFirst();
int columnIndex = cursor.getColumnIndex(projection[0]);
videoId = cursor.getLong(columnIndex);
Log.d(TAG,"Video ID is " + videoId);
cursor.close();
return videoId;
}

Fondamentalement, la DATA colonne de MediaStore (ou n'importe quel sous-section vous interrogez) stocke le chemin d'accès au fichier, vous pouvez donc utiliser ce que vous savez de chercher les DATA champ, ou utilisez le champ rechercher tout ce que vous voulez.

Je puis encore utiliser le Scheme comme ci-dessus pour savoir quoi faire avec mes données:

 private boolean  getSelectedVideo(Intent imageReturnedIntent, boolean fromData) {
Uri selectedVideoUri;
//Selected image returned from another activity
//A parameter I pass myself to know whether or not I'm being "shared via" or
//whether I'm working internally to my app (fromData = working internally)
if(fromData){
selectedVideoUri = imageReturnedIntent.getData();
} else {
//Selected image returned from SEND intent 
//which I register to receive in my manifest
//(so people can "share via" my app)
selectedVideoUri = (Uri)getIntent().getExtras().get(Intent.EXTRA_STREAM);
}
Log.d(TAG,"SelectedVideoUri = " + selectedVideoUri);
String filePath;
String scheme = selectedVideoUri.getScheme(); 
ContentResolver contentResolver = getContentResolver();
long videoId;
//If we are sent file://something or content://org.openintents.filemanager/mimetype/something...
if(scheme.equals("file") || (scheme.equals("content") && selectedVideoUri.getEncodedAuthority().equals("org.openintents.filemanager"))){
//Get the path
filePath = selectedVideoUri.getPath();
//Trim the path if necessary
//openintents filemanager returns content://org.openintents.filemanager/mimetype//mnt/sdcard/xxxx.mp4
if(filePath.startsWith("/mimetype/")){
String trimmedFilePath = filePath.substring("/mimetype/".length());
filePath = trimmedFilePath.substring(trimmedFilePath.indexOf("/"));
}
//Get the video ID from the path
videoId = getVideoIdFromFilePath(filePath, contentResolver);
} else if(scheme.equals("content")){
//If we are given another content://URI, look it up in the media provider
videoId = Long.valueOf(selectedVideoUri.getLastPathSegment());
filePath = getFilePathFromContentUri(selectedVideoUri, contentResolver);
} else {
Log.d(TAG,"Failed to load URI " + selectedVideoUri.toString());
return false;
}
return true;
}

essayer ce chemin du fichier image à partir de l'Uri

public void getImageFilePath(Context context, Uri uri) {
Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
cursor.moveToFirst();
String image_id = cursor.getString(0);
image_id = image_id.substring(image_id.lastIndexOf(":") + 1);
cursor.close();
cursor = context.getContentResolver().query(android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI, null, MediaStore.Images.Media._ID + " = ? ", new String[]{image_id}, null);
cursor.moveToFirst();
String path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
cursor.close();
upLoadImageOrLogo(path);
}

Solution pour ceux qui ont des problèmes après le passage à KitKat:

"Cela permet d'obtenir le chemin d'accès au fichier de la MediaProvider, DownloadsProvider, et ExternalStorageProvider, alors qu'elle a diminué pour la officieux de ContentProvider méthode" https://stackoverflow.com/a/20559175/690777

Depuis managedQuery a été abandonné, vous pourriez essayer:

CursorLoader cursorLoader = new CursorLoader(context, uri, proj, null, null, null);
Cursor cursor = cursorLoader.loadInBackground();

Cette solution fonctionne pour tous les cas:

C'est trop dur, dans certains cas, obtenir le chemin d'accès à partir de l'URL. Alors, pourquoi avez-vous besoin de la chemin? Pour copier le fichier dans un autre endroit? Vous n'avez pas besoin de le chemin.

public void SavePhotoUri (Uri imageuri, String Filename){
File FilePath = context.getDir(Environment.DIRECTORY_PICTURES,Context.MODE_PRIVATE);
try {
Bitmap selectedImage = MediaStore.Images.Media.getBitmap(context.getContentResolver(), imageuri);
String destinationImagePath = FilePath + "/" + Filename;
FileOutputStream destination = new FileOutputStream(destinationImagePath);
selectedImage.compress(Bitmap.CompressFormat.JPEG, 100, destination);
destination.close();
}
catch (Exception e) {
Log.e("error", e.toString());
}
}

Ici, vous obtenez le nom du fichier

String[] projection = {MediaStore.MediaColumns.DISPLAY_NAME};
Uri uri = data.getData();
String fileName = null;
ContentResolver cr = getActivity().getApplicationContext().getContentResolver();
Cursor metaCursor = cr.query(uri,
projection, null, null, null);
if (metaCursor != null) {
try {
if (metaCursor.moveToFirst()) {
fileName = metaCursor.getString(0);
}
} finally {
metaCursor.close();
}
}

Essayer Cette

Encore, si vous avez trouvé le problème pour obtenir le chemin réel, vous pouvez essayer mes réponses. Réponses ci-dessus ne m'a pas aidé.

Explication:- Cette méthode est l'URI et puis vérifier le niveau de l'API de votre appareil Android après que, selon le niveau API, il génère le chemin Réel. Code pour générer chemin réel de la méthode est différente selon API niveaux.

1. méthode pour obtenir le Véritable chemin de l'URI

   @SuppressLint("ObsoleteSdkInt")
   public String getPathFromURI(Uri uri){
   String realPath="";
   //SDK < API11
   if (Build.VERSION.SDK_INT < 11) {
   String[] proj = { MediaStore.Images.Media.DATA };
   @SuppressLint("Recycle") Cursor cursor = getContentResolver().query(uri, proj, null, null, null);
   int column_index = 0;
   String result="";
   if (cursor != null) {
   column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
   realPath=cursor.getString(column_index);
   }
   }
   //SDK >= 11 && SDK < 19
   else if (Build.VERSION.SDK_INT < 19){
   String[] proj = { MediaStore.Images.Media.DATA };
   CursorLoader cursorLoader = new CursorLoader(this, uri, proj, null, null, null);
   Cursor cursor = cursorLoader.loadInBackground();
   if(cursor != null){
   int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
   cursor.moveToFirst();
   realPath = cursor.getString(column_index);
   }
   }
   //SDK > 19 (Android 4.4)
   else{
   String wholeID = DocumentsContract.getDocumentId(uri);
   //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 = getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, column, sel, new String[]{ id }, null);
   int columnIndex = 0;
   if (cursor != null) {
   columnIndex = cursor.getColumnIndex(column[0]);
   if (cursor.moveToFirst()) {
   realPath = cursor.getString(columnIndex);
   }
   cursor.close();
   }
   }
   return realPath;
   }

2. Utiliser cette méthode comme ceci

   Log.e(TAG, "getRealPathFromURI: "+getPathFromURI(your_selected_uri) );

De sortie:-

04-06 12:39:46.993 6138-6138/com.app.lui E/tag: getRealPathFromURI:
/storage/emulated/0/Video/avengers_infinity_war_4k_8k-7680x4320.jpg

Parfaitement de travail pour moi à code fixe à partir de ce post:

  public static String getRealPathImageFromUri(Uri uri) {
String fileName =null;
if (uri.getScheme().equals("content")) {
try (Cursor cursor = MyApplication.getInstance().getContentResolver().query(uri, null, null, null, null)) {
if (cursor.moveToFirst()) {
fileName = cursor.getString(cursor.getColumnIndexOrThrow(ediaStore.Images.Media.DATA));
}
} catch (IllegalArgumentException e) {
Log.e(mTag, "Get path failed", e);
}
}
return fileName;
}

Depuis les réponses ci-dessus ne fonctionne pas pour moi, ici, c'est la solution qui a fonctionné pour moi:

Pour les deux >19 et <=19 API Niveaux.

Cette méthode couvre tous les cas d'obtenir de chemin d'uri

/**
* Get a file path from a Uri. This will get the the path for Storage Access
* Framework Documents, as well as the _data field for the MediaStore and
* other file-based ContentProviders.
*
* @param context The activity.
* @param uri The Uri to query.
* @author paulburke
*/
public static String getPath(final Context context, final Uri uri) {
//DocumentProvider
if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
//ExternalStorageProvider
if (isExternalStorageDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
if ("primary".equalsIgnoreCase(type)) {
return Environment.getExternalStorageDirectory() + "/" + split[1];
}else{
Toast.makeText(context, "Could not get file path. Please try again", Toast.LENGTH_SHORT).show();
}
}
//DownloadsProvider
else if (isDownloadsDocument(uri)) {
final String id = DocumentsContract.getDocumentId(uri);
final Uri contentUri = ContentUris.withAppendedId(
Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
return getDataColumn(context, contentUri, null, null);
}
//MediaProvider
else if (isMediaDocument(uri)) {
final String docId = DocumentsContract.getDocumentId(uri);
final String[] split = docId.split(":");
final String type = split[0];
Uri contentUri = null;
if ("image".equals(type)) {
contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
} else if ("video".equals(type)) {
contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
} else if ("audio".equals(type)) {
contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
} else {
contentUri = MediaStore.Files.getContentUri("external");
}
final String selection = "_id=?";
final String[] selectionArgs = new String[] {
split[1]
};
return getDataColumn(context, contentUri, selection, selectionArgs);
}
}
//MediaStore (and general)
else if ("content".equalsIgnoreCase(uri.getScheme())) {
return getDataColumn(context, uri, null, null);
}
//File
else if ("file".equalsIgnoreCase(uri.getScheme())) {
return uri.getPath();
}
return null;
}