Android 选择文件返回路径怎么就这么难？

r囧r小猫 2022-11-15 11:49 266阅读 0赞

# Android 选择文件返回路径怎么就这么难？ #

> 这个问题纠结了我很长时间，终于有了比较好的解决方案。目前已知适配所有的机型，有问题就留言吧。

## 正确姿势来一遍 ##

### 1. 打开系统自带的文件浏览器并限制类型 ###

public void OpenFile(View view) {
            // 指定类型
            String[] mimeTypes = {"*/*"};
           // String[] mimeTypes = {"application/octet-stream"}; // 指定bin类型
            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
            intent.addCategory(Intent.CATEGORY_OPENABLE);
            StringBuilder mimeTypesStr = new StringBuilder();
            for (String mimeType : mimeTypes) {
                mimeTypesStr.append(mimeType).append("|");
            }
            intent.setType(mimeTypesStr.substring(0, mimeTypesStr.length() - 1));
            startActivityForResult(Intent.createChooser(intent, "ChooseFile"), REQUEST_FILE_CODE);
        }

其中`mimeTypes`是指定文件的类型，比如图片，比如Excel，即使设置了该属性，在某些机型上没有效果，所以在选择文件后还需要判断格式是否正确。

为了大家嫌麻烦，我把类型举例放在了文章末尾，方便大家进行查询。

## 2. 返回选择的数据 ##

final int REQUEST_FILE_CODE = 1000;
    
     @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (requestCode == REQUEST_FILE_CODE && resultCode == RESULT_OK) {
                Uri uri = data.getData();
                Log.d(TAG, "uri:" + uri);
                //String filePath = PickUtils.getPath(this, uri);
                //textView.setText(filePath);
            }
            super.onActivityResult(requestCode, resultCode, data);
        }

重点来了，我们可以很轻松的拿到`Uri`, 但是转`absolute path` 在不同的机型却遇到了奇奇怪怪的问题，至今没有完全弄明白。

大概的意思就是有些机型转path时会失败，比如在华为10.0的机型上，通过`下载内容`中打开`Download`的文件就会失败，场景是原本的`documentid`可以转为long型，但它变成了这个样子`msf:123`，导致转换失败。

有很多人都存在这个问题，比如这个地址：https://stackoverflow.com/questions/58660420/api-level-29-intent-action-get-content-returning-wrong-id-from-downloads-folder

解决方法：在转换绝对路径失败的情况，将文件拷贝到自己的app的缓存目录下，然后返回路径。 代码在文章末尾。

## 3. 思考与拓展 ##

我们可以轻松的拿到Uri之后，实际上在不转绝对路径的情况下，用Uri已经可以做很多事情了，比如获取文件类型、比如获取文件的byte\[\]、获取文件名 等等。

*  获取文件类型，返回的结果需要在`类型对应`中去对照。

/**
         * 获取文件的类型。
         * @param context 上下文
         * @param uri uri
         * @return
         */
        public static String getFormatByUri(@NonNull Context context, @NonNull Uri uri) {
            String type = context.getContentResolver().getType(uri);
            if (TextUtils.isEmpty(type)) return null;
            return type;
        }

*  获取字节数组

/**
         * 根据uri获取 byte[]
         * @param context
         * @param uri
         * @return
         * @throws IOException
         */
        public static byte[] getBytesByUri(Context context, Uri uri) throws IOException {
            InputStream iStream = context.getContentResolver().openInputStream(uri);
            if (iStream == null) return null;
            return getBytes(iStream);
        }
    
        private static byte[] getBytes(InputStream inputStream) throws IOException {
            ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
    
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1) {
                byteBuffer.write(buffer, 0, len);
            }
            return byteBuffer.toByteArray();
        }

*  获取文件名

/**
         * 获取文件名
         * @param uri uri
         * @return
         */
        public String getFileNameByUri(Uri uri) {
            String filename = "";
            Cursor returnCursor = getContentResolver().query(uri, null,
                    null, null, null);
            if (returnCursor != null) {
                int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
                returnCursor.moveToFirst();
                filename = returnCursor.getString(nameIndex);
                returnCursor.close();
            }
            return filename;
        }

## 4. URI 转 Path ##

当然，这个完美的工具类还是提供给大家。出处我不记得了，我稍微改了一点，目前用下来非常完美。 只是在转path不成功的情况下，会拷贝文件放到应用的缓存目录，大家需要注意下清理缓存的时机。

import android.annotation.SuppressLint;
    import android.content.ContentUris;
    import android.content.Context;
    import android.database.Cursor;
    import android.net.Uri;
    import android.os.Build;
    import android.os.Environment;
    import android.provider.DocumentsContract;
    import android.provider.MediaStore;
    import android.provider.OpenableColumns;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    import android.util.Log;
    
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * Created by pangw on 2018/5/23.
     */
    public class PickUtils {
    
        public static final String DOCUMENTS_DIR = "documents";
    
        @SuppressLint("NewApi")
        public static String getPath(final Context context, final Uri uri) {
    
            final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
    
            // DocumentProvider
            if (isKitKat && 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];
                    }
                }
                // DownloadsProvider
                else if (isDownloadsDocument(uri)) {
    
                    final String id = DocumentsContract.getDocumentId(uri);
    
                    if (id != null && id.startsWith("raw:")) {
                        return id.substring(4);
                    }
    
                    String[] contentUriPrefixesToTry = new String[]{
                            "content://downloads/public_downloads",
                            "content://downloads/my_downloads"
                    };
    
                    for (String contentUriPrefix : contentUriPrefixesToTry) {
                        try {
                            // note: id 可能为字符串，如在华为10.0系统上，选择文件后id为："msf:254"，导致转Long异常
                            Uri contentUri = ContentUris.withAppendedId(Uri.parse(contentUriPrefix), Long.parseLong(id));
                            String path = getDataColumn(context, contentUri, null, null);
                            if (path != null && !path.equals("")) {
                                return path;
                            }
                        } catch (Exception e) {
                        }
                    }
    
                    // path could not be retrieved using ContentResolver, therefore copy file to accessible cache using streams
                    String fileName = getFileName(context, uri);
                    File cacheDir = getDocumentCacheDir(context);
                    File file = generateFileName(fileName, cacheDir);
                    String destinationPath = null;
                    if (file != null) {
                        destinationPath = file.getAbsolutePath();
                        saveFileFromUri(context, uri, destinationPath);
                    }
    
                    return destinationPath;
                }
                // 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())) {
                String path = getDataColumn(context, uri, null, null);
                if (path != null && !path.equals("")) return path;
    
                // path could not be retrieved using ContentResolver, therefore copy file to accessible cache using streams
                String fileName = getFileName(context, uri);
                File cacheDir = getDocumentCacheDir(context);
                File file = generateFileName(fileName, cacheDir);
                String destinationPath = null;
                if (file != null) {
                    destinationPath = file.getAbsolutePath();
                    saveFileFromUri(context, uri, destinationPath);
                }
                return destinationPath;
            }
            // File
            else if ("file".equalsIgnoreCase(uri.getScheme())) {
                return uri.getPath();
            }
            return null;
        }
    
        /**
         * @param uri The Uri to check.
         * @return Whether the Uri authority is ExternalStorageProvider.
         */
        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.
         */
        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.
         */
        public static boolean isMediaDocument(Uri uri) {
            return "com.android.providers.media.documents".equals(uri.getAuthority());
        }
    
        public static String getDataColumn(Context context, Uri uri, String selection,
                                           String[] selectionArgs) {
    
            Cursor cursor = null;
            final String column = "_data";
            final String[] projection = {column};
            String path = "";
            try {
                cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                        null);
                if (cursor != null && cursor.moveToFirst()) {
                    final int column_index = cursor.getColumnIndexOrThrow(column);
                    path = cursor.getString(column_index);
                    return path;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (cursor != null)
                    cursor.close();
            }
            return path;
        }
    
        public static String getFileName(@NonNull Context context, Uri uri) {
            String mimeType = context.getContentResolver().getType(uri);
            String filename = null;
            if (mimeType == null && context != null) {
                String path = getPath(context, uri);
                if (path == null) {
                    filename = getName(uri.toString());
                } else {
                    File file = new File(path);
                    filename = file.getName();
                }
            } else {
                Cursor returnCursor = context.getContentResolver().query(uri, null,
                        null, null, null);
                if (returnCursor != null) {
                    int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
                    returnCursor.moveToFirst();
                    filename = returnCursor.getString(nameIndex);
                    returnCursor.close();
                }
            }
    
            return filename;
        }
    
        public static String getName(String filename) {
            if (filename == null) {
                return null;
            }
            int index = filename.lastIndexOf('/');
            return filename.substring(index + 1);
        }
    
        public static File getDocumentCacheDir(@NonNull Context context) {
            Log.d("PickUtils", "getDocumentCacheDir");
            File dir = new File(context.getCacheDir(), DOCUMENTS_DIR);
            if (!dir.exists()) {
                dir.mkdirs();
            }
    
            return dir;
        }
    
        @Nullable
        public static File generateFileName(@Nullable String name, File directory) {
            if (name == null) {
                return null;
            }
    
            File file = new File(directory, name);
    
            if (file.exists()) {
                String fileName = name;
                String extension = "";
                int dotIndex = name.lastIndexOf('.');
                if (dotIndex > 0) {
                    fileName = name.substring(0, dotIndex);
                    extension = name.substring(dotIndex);
                }
    
                int index = 0;
    
                while (file.exists()) {
                    index++;
                    name = fileName + '(' + index + ')' + extension;
                    file = new File(directory, name);
                }
            }
    
            try {
                if (!file.createNewFile()) {
                    return null;
                }
            } catch (IOException e) {
                return null;
            }
    
            return file;
        }
    
    
        private static void saveFileFromUri(Context context, Uri uri, String destinationPath) {
            InputStream is = null;
            BufferedOutputStream bos = null;
            try {
                is = context.getContentResolver().openInputStream(uri);
                bos = new BufferedOutputStream(new FileOutputStream(destinationPath, false));
                byte[] buf = new byte[1024];
                is.read(buf);
                do {
                    bos.write(buf);
                } while (is.read(buf) != -1);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (is != null) is.close();
                    if (bos != null) bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }

## 5. 类型对应 ##

private final String[][] MIME_MapTable={
     
    　　//{后缀名，MIME类型}
     
    　　{".3gp", "video/3gpp"},
     
    　　{".apk", "application/vnd.android.package-archive"},
     
    　　{".asf", "video/x-ms-asf"},
     
    　　{".avi", "video/x-msvideo"},
     
    　　{".bin", "application/octet-stream"},
     
    　　{".bmp", "image/bmp"},
     
    　　{".c", "text/plain"},
     
    　　{".class", "application/octet-stream"},
     
    　　{".conf", "text/plain"},
     
    　　{".cpp", "text/plain"},
     
    　　{".doc", "application/msword"},
     
    　　{".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
     
    　　{".xls", "application/vnd.ms-excel"},
     
    　　{".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
     
    　　{".exe", "application/octet-stream"},
     
    　　{".gif", "image/gif"},
     
    　　{".gtar", "application/x-gtar"},
     
    　　{".gz", "application/x-gzip"},
     
    　　{".h", "text/plain"},
     
    　　{".htm", "text/html"},
     
    　　{".html", "text/html"},
     
    　　{".jar", "application/java-archive"},
     
    　　{".java", "text/plain"},
     
    　　{".jpeg", "image/jpeg"},
     
    　　{".jpg", "image/jpeg"},
     
    　　{".js", "application/x-javascript"},
     
    　　{".log", "text/plain"},
     
    　　{".m3u", "audio/x-mpegurl"},
     
    　　{".m4a", "audio/mp4a-latm"},
     
    　　{".m4b", "audio/mp4a-latm"},
     
    　　{".m4p", "audio/mp4a-latm"},
     
    　　{".m4u", "video/vnd.mpegurl"},
     
    　　{".m4v", "video/x-m4v"},
     
    　　{".mov", "video/quicktime"},
     
    　　{".mp2", "audio/x-mpeg"},
     
    　　{".mp3", "audio/x-mpeg"},
     
    　　{".mp4", "video/mp4"},
     
    　　{".mpc", "application/vnd.mpohun.certificate"},
     
    　　{".mpe", "video/mpeg"},
     
    　　{".mpeg", "video/mpeg"},
     
    　　{".mpg", "video/mpeg"},
     
    　　{".mpg4", "video/mp4"},
     
    　　{".mpga", "audio/mpeg"},
     
    　　{".msg", "application/vnd.ms-outlook"},
     
    　　{".ogg", "audio/ogg"},
     
    　　{".pdf", "application/pdf"},
     
    　　{".png", "image/png"},
     
    　　{".pps", "application/vnd.ms-powerpoint"},
     
    　　{".ppt", "application/vnd.ms-powerpoint"},
     
    　　{".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
     
    　　{".prop", "text/plain"},
     
    　　{".rc", "text/plain"},
     
    　　{".rmvb", "audio/x-pn-realaudio"},
     
    　　{".rtf", "application/rtf"},
     
    　　{".sh", "text/plain"},
     
    　　{".tar", "application/x-tar"},
     
    　　{".tgz", "application/x-compressed"},
     
    　　{".txt", "text/plain"},
     
    　　{".wav", "audio/x-wav"},
     
    　　{".wma", "audio/x-ms-wma"},
     
    　　{".wmv", "audio/x-ms-wmv"},
     
    　　{".wps", "application/vnd.ms-works"},
     
    　　{".xml", "text/plain"},
     
    　　{".z", "application/x-compress"},
     
    　　{".zip", "application/x-zip-compressed"},
     
    　　{"", "*/*"}
     
    　　};