android - Get filename and path from URI from mediastore


Translate

I have an onActivityResult returning from an mediastore image selection which I can get a URI for an image using the following:

Uri selectedImage = data.getData();

Converting this to a string gives this:

content://media/external/images/media/47

Or to a path gives:

/external/images/media/47

However I can't seem to find a way to convert this into an absolute path, as I want to load the image into a bitmap without having to copy it somewhere. I know this can be done using the URI and content resolver, but this seems to break on rebooting of the phone, I guess MediaStore doesn't keep its numbering the same between reboots.


All Answers
  • Translate

    Below API 19 use this code to get File Path from URI:

    public String getRealPathFromURI(Context context, Uri contentUri) {
      Cursor cursor = null;
      try { 
        String[] proj = { MediaStore.Images.Media.DATA };
        cursor = context.getContentResolver().query(contentUri,  proj, null, null, null);
        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
      } finally {
        if (cursor != null) {
          cursor.close();
        }
      }
    }
    

  • Translate

    Just a simple update on the first answer: mActivity.managedQuery() is now deprecated. I've updated the code with the new method.

    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


  • Translate

    For Oreo

    Uri uri = data.getData(); 
    File file = new File(uri.getPath());//create path from uri
    final String[] split = file.getPath().split(":");//split the path.
    filePath = split[1];//assign it to a string(your choice).
    

    For All version below Oreo I have made this method which get real path from uri

     @SuppressLint("NewApi")
        public static String getFilePath(Context context, Uri uri) throws URISyntaxException {
            String selection = null;
            String[] selectionArgs = null;
            // Uri is different in versions after KITKAT (Android 4.4), we need to
            if (Build.VERSION.SDK_INT >= 19 && DocumentsContract.isDocumentUri(context.getApplicationContext(), uri)) {
                if (isExternalStorageDocument(uri)) {
                    final String docId = DocumentsContract.getDocumentId(uri);
                    final String[] split = docId.split(":");
                    return Environment.getExternalStorageDirectory() + "/" + split[1];
                } else if (isDownloadsDocument(uri)) {
                    final String id = DocumentsContract.getDocumentId(uri);
                    uri = ContentUris.withAppendedId(
                            Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
                } else if (isMediaDocument(uri)) {
                    final String docId = DocumentsContract.getDocumentId(uri);
                    final String[] split = docId.split(":");
                    final String type = split[0];
                    if ("image".equals(type)) {
                        uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                    } else if ("video".equals(type)) {
                        uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                    } else if ("audio".equals(type)) {
                        uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                    }
                    selection = "_id=?";
                    selectionArgs = new String[]{
                            split[1]
                    };
                }
            }
            if ("content".equalsIgnoreCase(uri.getScheme())) {
    
    
              if (isGooglePhotosUri(uri)) {
                  return uri.getLastPathSegment();
               }
    
                String[] projection = {
                        MediaStore.Images.Media.DATA
                };
                Cursor cursor = null;
                try {
                    cursor = context.getContentResolver()
                            .query(uri, projection, selection, selectionArgs, null);
                    int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                    if (cursor.moveToFirst()) {
                        return cursor.getString(column_index);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else if ("file".equalsIgnoreCase(uri.getScheme())) {
                return uri.getPath();
            }
            return null;
        }
    
        public static boolean isExternalStorageDocument(Uri uri) {
            return "com.android.externalstorage.documents".equals(uri.getAuthority());
        }
    
        public static boolean isDownloadsDocument(Uri uri) {
            return "com.android.providers.downloads.documents".equals(uri.getAuthority());
        }
    
        public static boolean isMediaDocument(Uri uri) {
            return "com.android.providers.media.documents".equals(uri.getAuthority());
        }
    
      public static boolean isGooglePhotosUri(Uri uri) {
        return "com.google.android.apps.photos.content".equals(uri.getAuthority());
    }
    

  • Translate

    Don't try to find a uri in the filesystem, that's slow to go look things up in the database.

    You can get a bitmap from a uri by giving an input stream to the factory like you give a file to the factory:

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

  • Translate

    Here it is my example of getting file name, from URI like file://... and content://... . It's works for me not only with Android MediaStore but also with third part application like EzExplorer.

    public static String getFileNameByUri(Context context, Uri uri)
    {
        String fileName="unknown";//default fileName
        Uri filePathUri = uri;
        if (uri.getScheme().toString().compareTo("content")==0)
        {      
            Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
            if (cursor.moveToFirst())
            {
                int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);//Instead of "MediaStore.Images.Media.DATA" can be used "_data"
                filePathUri = Uri.parse(cursor.getString(column_index));
                fileName = filePathUri.getLastPathSegment().toString();
            }
        }
        else if (uri.getScheme().compareTo("file")==0)
        {
            fileName = filePathUri.getLastPathSegment().toString();
        }
        else
        {
            fileName = fileName+"_"+filePathUri.getLastPathSegment();
        }
        return fileName;
    }
    

  • Translate

    Good existing answers, some of which I used to come up with my own:

    I have to get the path from URIs and get the URI from paths, and Google has a hard time telling the difference so for anyone who has the same issue (e.g., to get the thumbnail from the MediaStore of a video whose physical location you already have). The former:

    /**
     * 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;
    }
    

    The latter (which I do for videos, but can also be used for Audio or Files or other types of stored content by substituting MediaStore.Audio (etc) for MediaStore.Video):

    /**
     * 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;
    }
    

    Basically, the DATA column of MediaStore (or whichever sub-section of it you're querying) stores the file path, so you either use what you know to look up that DATA field, or use the field to look up whatever else you want.

    I then further use the Scheme as above to figure out what to do with my data:

     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;
     }
    

  • Translate

    None of these answers worked for me in all cases. I had to go directly to Google's Documentation https://developer.android.com/guide/topics/providers/document-provider.html on this topic and found this useful method:

    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;
    }
    

    You can use this bitmap to display it in an Image View.


  • Translate

    try this get image file path from 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);
    }
    

  • Translate

    API 19 and Above, Image File Path from Uri works perfectly. I also check this latest PIE API 28.

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

  • Translate

    Solution for those, who have problem after moving to KitKat:

    "This will get the file path from the MediaProvider, DownloadsProvider, and ExternalStorageProvider, while falling back to the unofficial ContentProvider method" https://stackoverflow.com/a/20559175/690777


  • Translate

    After getting an image from the gallery, just pass the URI in the below method only for Android 4.4 (KitKat):

    public String getPath(Uri contentUri) {// Will return "image:x*"
    
        String wholeID = DocumentsContract.getDocumentId(contentUri);
    
        // 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);
    
        String filePath = "";
    
        int columnIndex = cursor.getColumnIndex(column[0]);
    
        if (cursor.moveToFirst()) {
            filePath = cursor.getString(columnIndex);
        }
    
        cursor.close();
        return filePath;
    }
    

  • Translate

    Since managedQuery has been deprecated, you could try:

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

  • Translate

    Here I am going to show you that how to create a BROWSE button, which when you will click, it will open up the SD card, you will select a File and as a result you will get the file name and file path of the selected one:

    A button which you will hit

    browse.setOnClickListener(new OnClickListener()
    {
        public void onClick(View v)
        {
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_PICK);
            Uri startDir = Uri.fromFile(new File("/sdcard"));
            startActivityForResult(intent, PICK_REQUEST_CODE);
        }
    });
    

    The function which will get the Resulted File Name and File Path

    protected void onActivityResult(int requestCode, int resultCode, Intent intent)
    {
        if (requestCode == PICK_REQUEST_CODE)
        {
            if (resultCode == RESULT_OK)
            {
                Uri uri = intent.getData();
    
                if (uri.getScheme().toString().compareTo("content")==0)
                {
                    Cursor cursor =getContentResolver().query(uri, null, null, null, null);
                    if (cursor.moveToFirst())
                    {
                        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);//Instead of "MediaStore.Images.Media.DATA" can be used "_data"
                        Uri filePathUri = Uri.parse(cursor.getString(column_index));
                        String file_name = filePathUri.getLastPathSegment().toString();
                        String file_path=filePathUri.getPath();
                        Toast.makeText(this,"File Name & PATH are:"+file_name+"\n"+file_path, Toast.LENGTH_LONG).show();
                    }
                }
            }
        }
    }
    

  • Translate

    This solution works for every case:

    It is too hard in some cases get the path from the URL. Then why do you need the path? To copy the file in other place? You don't need the path.

    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());
        }
    }
    

  • Translate

    Try This

    Still, if you are getting the problem to get the real path, you can try my answers. Above answers didn't help me.

    Explanation:- This method gets the URI and then check the API level of your Android device after that according to API level it will generate the Real path. Code for generating real path method is different according to API levels.

    1. method to get the Real path from 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. Use this method like this

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

    Output:-

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


  • Translate

    I've done like this:

        Uri queryUri = MediaStore.Files.getContentUri("external");
        String columnData = MediaStore.Files.FileColumns.DATA;
        String columnSize = MediaStore.Files.FileColumns.SIZE;
    
        String[] projectionData = {MediaStore.Files.FileColumns.DATA};
    
    
        String name = null;
        String size = null;
    
        Cursor cursor = getContentResolver().query(contentURI, null, null, null, null);
        if ((cursor != null)&&(cursor.getCount()>0)) {
            int nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
            int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
    
            cursor.moveToFirst();
    
            name = cursor.getString(nameIndex);
            size = cursor.getString(sizeIndex);
    
            cursor.close();
        }
    
        if ((name!=null)&&(size!=null)){
            String selectionNS = columnData + " LIKE '%" + name + "' AND " +columnSize + "='" + size +"'";
    
            Cursor cursorLike = getContentResolver().query(queryUri, projectionData, selectionNS, null, null);
    
            if ((cursorLike != null)&&(cursorLike.getCount()>0)) {
                cursorLike.moveToFirst();
                int indexData = cursorLike.getColumnIndex(columnData);
                if (cursorLike.getString(indexData) != null) {
                    result = cursorLike.getString(indexData);
                }
                cursorLike.close();
            }
        }
    
        return result;
    

  • Translate

    Slightly modified version of @PercyPercy - it doesn't throw and just returns null if anything goes wrong:

    public String getPathFromMediaUri(Context context, Uri uri) {
        String result = null;
    
        String[] projection = { MediaStore.Images.Media.DATA };
        Cursor cursor = context.getContentResolver().query(uri, projection, null, null, null);
        int col = cursor.getColumnIndex(MediaStore.Images.Media.DATA);
        if (col >= 0 && cursor.moveToFirst())
            result = cursor.getString(col);
        cursor.close();
    
        return result;
    }
    

  • Translate

    Here you get the name of the file

    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();
                            }
                        }
    

  • Translate

    Simple and easy. You can do this from the URI just like below!

    public void getContents(Uri uri)
    {
        Cursor vidCursor = getActivity.getContentResolver().query(uri, null, null,
                                                                  null, null);
        if (vidCursor.moveToFirst())
        {
            int column_index =
            vidCursor .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            Uri filePathUri = Uri.parse(vidCursor .getString(column_index));
            String video_name =  filePathUri.getLastPathSegment().toString();
            String file_path=filePathUri.getPath();
            Log.i("TAG", video_name + "\b" file_path);
        }
    }
    

  • Translate

    Any way for post Android Q, when MediaStore.Images.Media.DATA won't be available anymore? This field is depreciated in Android Q:

    This constant was deprecated in API level 29. Apps may not have filesystem permissions to directly access this path. Instead of trying to open this path directly, apps should use ContentResolver#openFileDescriptor(Uri, String) to gain access.

    https://developer.android.com/reference/android/provider/MediaStore.MediaColumns.html#DATA


  • Translate

    Perfectly working for me fixed code from this 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;
        }
    

  • Translate

    As an add-on, if you need to see if a file exists before you try to open an input stream, you can use the DocumentsContract.

    (Kotlin code)

    var iStream = null
    if(DocumentsContract.isDocumentUri(context,myUri)) {
       val pfd: ParcelFileDescriptor? = context.contentResolver.openFileDescriptor(
                myUri, "r") ?: return null
       iStream = ParcelFileDescriptor.AutoCloseInputStream(pfd)
    }
    

  • Translate

    Since the above answers didn't work for me, here is the solution that worked for me:

    For both >19 and <=19 API Levels.

    This method covers all the cases to get filePath from 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;
    }
    

  • Translate

    To get any sort of file path use this :

    /*
     * Copyright (C) 2007-2008 OpenIntents.org
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package com.yourpackage;
    
    import android.content.ContentResolver;
    import android.content.ContentUris;
    import android.content.Context;
    import android.content.Intent;
    import android.database.Cursor;
    import android.database.DatabaseUtils;
    import android.graphics.Bitmap;
    import android.net.Uri;
    import android.os.Build;
    import android.os.Environment;
    import android.provider.DocumentsContract;
    import android.provider.MediaStore;
    import android.util.Log;
    import android.webkit.MimeTypeMap;
    
    import java.io.File;
    import java.io.FileFilter;
    import java.text.DecimalFormat;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * @author Peli
     * @author paulburke (ipaulpro)
     * @version 2013-12-11
     */
    public class FileUtils {
        private FileUtils() {
        } //private constructor to enforce Singleton pattern
    
        /**
         * TAG for log messages.
         */
        static final String TAG = "FileUtils";
        private static final boolean DEBUG = true; // Set to true to enable logging
    
        public static final String MIME_TYPE_AUDIO = "audio/*";
        public static final String MIME_TYPE_TEXT = "text/*";
        public static final String MIME_TYPE_IMAGE = "image/*";
        public static final String MIME_TYPE_VIDEO = "video/*";
        public static final String MIME_TYPE_APP = "application/*";
    
        public static final String HIDDEN_PREFIX = ".";
    
        /**
         * Gets the extension of a file name, like ".png" or ".jpg".
         *
         * @param uri
         * @return Extension including the dot("."); "" if there is no extension;
         * null if uri was null.
         */
        public static String getExtension(String uri) {
            if (uri == null) {
                return null;
            }
    
            int dot = uri.lastIndexOf(".");
            if (dot >= 0) {
                return uri.substring(dot);
            } else {
                // No extension.
                return "";
            }
        }
    
        /**
         * @return Whether the URI is a local one.
         */
        public static boolean isLocal(String url) {
            if (url != null && !url.startsWith("http://") && !url.startsWith("https://")) {
                return true;
            }
            return false;
        }
    
        /**
         * @return True if Uri is a MediaStore Uri.
         * @author paulburke
         */
        public static boolean isMediaUri(Uri uri) {
            return "media".equalsIgnoreCase(uri.getAuthority());
        }
    
        /**
         * Convert File into Uri.
         *
         * @param file
         * @return uri
         */
        public static Uri getUri(File file) {
            if (file != null) {
                return Uri.fromFile(file);
            }
            return null;
        }
    
        /**
         * Returns the path only (without file name).
         *
         * @param file
         * @return
         */
        public static File getPathWithoutFilename(File file) {
            if (file != null) {
                if (file.isDirectory()) {
                    // no file to be split off. Return everything
                    return file;
                } else {
                    String filename = file.getName();
                    String filepath = file.getAbsolutePath();
    
                    // Construct path without file name.
                    String pathwithoutname = filepath.substring(0,
                            filepath.length() - filename.length());
                    if (pathwithoutname.endsWith("/")) {
                        pathwithoutname = pathwithoutname.substring(0, pathwithoutname.length() - 1);
                    }
                    return new File(pathwithoutname);
                }
            }
            return null;
        }
    
        /**
         * @return The MIME type for the given file.
         */
        public static String getMimeType(File file) {
    
            String extension = getExtension(file.getName());
    
            if (extension.length() > 0)
                return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.substring(1));
    
            return "application/octet-stream";
        }
    
        /**
         * @return The MIME type for the give Uri.
         */
        public static String getMimeType(Context context, Uri uri) {
            File file = new File(getPath(context, uri));
            return getMimeType(file);
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is {@link LocalStorageProvider}.
         * @author paulburke
         */
        public static boolean isLocalStorageDocument(Uri uri) {
            return LocalStorageProvider.AUTHORITY.equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is ExternalStorageProvider.
         * @author paulburke
         */
        public static boolean isExternalStorageDocument(Uri uri) {
            return "com.android.externalstorage.documents".equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is DownloadsProvider.
         * @author paulburke
         */
        public static boolean isDownloadsDocument(Uri uri) {
            return "com.android.providers.downloads.documents".equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is MediaProvider.
         * @author paulburke
         */
        public static boolean isMediaDocument(Uri uri) {
            return "com.android.providers.media.documents".equals(uri.getAuthority());
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is Google Photos.
         */
        public static boolean isGooglePhotosUri(Uri uri) {
            return "com.google.android.apps.photos.content".equals(uri.getAuthority());
        }
    
        /**
         * Get the value of the data column for this Uri. This is useful for
         * MediaStore Uris, and other file-based ContentProviders.
         *
         * @param context       The context.
         * @param uri           The Uri to query.
         * @param selection     (Optional) Filter used in the query.
         * @param selectionArgs (Optional) Selection arguments used in the query.
         * @return The value of the _data column, which is typically a file path.
         * @author paulburke
         */
        public static String getDataColumn(Context context, Uri uri, String selection,
                                           String[] selectionArgs) {
    
            Cursor cursor = null;
            final String column = "_data";
            final String[] projection = {
                    column
            };
    
            try {
                cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                        null);
                if (cursor != null && cursor.moveToFirst()) {
                    if (DEBUG)
                        DatabaseUtils.dumpCursor(cursor);
    
                    final int column_index = cursor.getColumnIndexOrThrow(column);
                    return cursor.getString(column_index);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if (cursor != null)
                    cursor.close();
            }
            return null;
        }
    
        /**
         * Get a file path from a Uri. This will quickGet the the path for Storage Access
         * Framework Documents, as well as the _data field for the MediaStore and
         * other file-based ContentProviders.<br>
         * <br>
         * Callers should check whether the path is local before assuming it
         * represents a local file.
         *
         * @param context The context.
         * @param uri     The Uri to query.
         * @author paulburke
         * @see #isLocal(String)
         * @see #getFile(Context, Uri)
         */
        public static String getPath(final Context context, final Uri uri) {
    
            if (DEBUG)
                Log.d(TAG + " File -",
                        "Authority: " + uri.getAuthority() +
                                ", Fragment: " + uri.getFragment() +
                                ", Port: " + uri.getPort() +
                                ", Query: " + uri.getQuery() +
                                ", Scheme: " + uri.getScheme() +
                                ", Host: " + uri.getHost() +
                                ", Segments: " + uri.getPathSegments().toString()
                );
            // DocumentProvider
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
                // LocalStorageProvider
                if (isLocalStorageDocument(uri)) {
                    // The path is the id
                    return DocumentsContract.getDocumentId(uri);
                }
                // ExternalStorageProvider
                else 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];
    //                }
                    return Environment.getExternalStorageDirectory() + "/" + split[1];
    
                    // TODO handle non-primary volumes
                }
                // DownloadsProvider
                else if (isDownloadsDocument(uri)) {
                    try {
                        final String id = DocumentsContract.getDocumentId(uri);
                        Log.d(TAG, "getPath: id= " + id);
                        final Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
                        return getDataColumn(context, contentUri, null, null);
                    }catch (Exception e){
                        e.printStackTrace();
                        List<String> segments = uri.getPathSegments();
                        if(segments.size() > 1) {
                            String rawPath = segments.get(1);
                            if(!rawPath.startsWith("/")){
                                return rawPath.substring(rawPath.indexOf("/"));
                            }else {
                                return rawPath;
                            }
                        }
                    }
                }
                // 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;
                    }
    
                    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 the remote address
                if (isGooglePhotosUri(uri))
                    return uri.getLastPathSegment();
    
                return getDataColumn(context, uri, null, null);
            }
            // File
            else if ("file".equalsIgnoreCase(uri.getScheme())) {
                return uri.getPath();
            }
    
            return null;
        }
    
        /**
         * Convert Uri into File, if possible.
         *
         * @return file A local file that the Uri was pointing to, or null if the
         * Uri is unsupported or pointed to a remote resource.
         * @author paulburke
         * @see #getPath(Context, Uri)
         */
        public static File getFile(Context context, Uri uri) {
            if (uri != null) {
                String path = getPath(context, uri);
                if (path != null && isLocal(path)) {
                    return new File(path);
                }
            }
            return null;
        }
    
        /**
         * Get the file size in a human-readable string.
         *
         * @param size
         * @return
         * @author paulburke
         */
        public static String getReadableFileSize(int size) {
            final int BYTES_IN_KILOBYTES = 1024;
            final DecimalFormat dec = new DecimalFormat("###.#");
            final String KILOBYTES = " KB";
            final String MEGABYTES = " MB";
            final String GIGABYTES = " GB";
            float fileSize = 0;
            String suffix = KILOBYTES;
    
            if (size > BYTES_IN_KILOBYTES) {
                fileSize = size / BYTES_IN_KILOBYTES;
                if (fileSize > BYTES_IN_KILOBYTES) {
                    fileSize = fileSize / BYTES_IN_KILOBYTES;
                    if (fileSize > BYTES_IN_KILOBYTES) {
                        fileSize = fileSize / BYTES_IN_KILOBYTES;
                        suffix = GIGABYTES;
                    } else {
                        suffix = MEGABYTES;
                    }
                }
            }
            return String.valueOf(dec.format(fileSize) + suffix);
        }
    
        /**
         * Attempt to retrieve the thumbnail of given File from the MediaStore. This
         * should not be called on the UI thread.
         *
         * @param context
         * @param file
         * @return
         * @author paulburke
         */
        public static Bitmap getThumbnail(Context context, File file) {
            return getThumbnail(context, getUri(file), getMimeType(file));
        }
    
        /**
         * Attempt to retrieve the thumbnail of given Uri from the MediaStore. This
         * should not be called on the UI thread.
         *
         * @param context
         * @param uri
         * @return
         * @author paulburke
         */
        public static Bitmap getThumbnail(Context context, Uri uri) {
            return getThumbnail(context, uri, getMimeType(context, uri));
        }
    
        /**
         * Attempt to retrieve the thumbnail of given Uri from the MediaStore. This
         * should not be called on the UI thread.
         *
         * @param context
         * @param uri
         * @param mimeType
         * @return
         * @author paulburke
         */
        public static Bitmap getThumbnail(Context context, Uri uri, String mimeType) {
            if (DEBUG)
                Log.d(TAG, "Attempting to quickGet thumbnail");
    
            if (!isMediaUri(uri)) {
                Log.e(TAG, "You can only retrieve thumbnails for images and videos.");
                return null;
            }
    
            Bitmap bm = null;
            if (uri != null) {
                final ContentResolver resolver = context.getContentResolver();
                Cursor cursor = null;
                try {
                    cursor = resolver.query(uri, null, null, null, null);
                    if (cursor.moveToFirst()) {
                        final int id = cursor.getInt(0);
                        if (DEBUG)
                            Log.d(TAG, "Got thumb ID: " + id);
    
                        if (mimeType.contains("video")) {
                            bm = MediaStore.Video.Thumbnails.getThumbnail(
                                    resolver,
                                    id,
                                    MediaStore.Video.Thumbnails.MINI_KIND,
                                    null);
                        } else if (mimeType.contains(FileUtils.MIME_TYPE_IMAGE)) {
                            bm = MediaStore.Images.Thumbnails.getThumbnail(
                                    resolver,
                                    id,
                                    MediaStore.Images.Thumbnails.MINI_KIND,
                                    null);
                        }
                    }
                } catch (Exception e) {
                    if (DEBUG)
                        Log.e(TAG, "getThumbnail", e);
                } finally {
                    if (cursor != null)
                        cursor.close();
                }
            }
            return bm;
        }
    
        /**
         * File and folder comparator. TODO Expose sorting option method
         *
         * @author paulburke
         */
        public static Comparator<File> sComparator = new Comparator<File>() {
            @Override
            public int compare(File f1, File f2) {
                // Sort alphabetically by lower case, which is much cleaner
                return f1.getName().toLowerCase().compareTo(
                        f2.getName().toLowerCase());
            }
        };
    
        /**
         * File (not directories) filter.
         *
         * @author paulburke
         */
        public static FileFilter sFileFilter = new FileFilter() {
            @Override
            public boolean accept(File file) {
                final String fileName = file.getName();
                // Return files only (not directories) and skip hidden files
                return file.isFile() && !fileName.startsWith(HIDDEN_PREFIX);
            }
        };
    
        /**
         * Folder (directories) filter.
         *
         * @author paulburke
         */
        public static FileFilter sDirFilter = new FileFilter() {
            @Override
            public boolean accept(File file) {
                final String fileName = file.getName();
                // Return directories only and skip hidden directories
                return file.isDirectory() && !fileName.startsWith(HIDDEN_PREFIX);
            }
        };
    
        /**
         * Get the Intent for selecting content to be used in an Intent Chooser.
         *
         * @return The intent for opening a file with Intent.createChooser()
         * @author paulburke
         */
        public static Intent createGetContentIntent() {
            // Implicitly allow the user to select a particular kind of data
            final Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
            // The MIME data type filter
            intent.setType("*/*");
            // Only return URIs that can be opened with ContentResolver
            intent.addCategory(Intent.CATEGORY_OPENABLE);
            return intent;
        }
    }
    

  • Translate

    Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);