Android 4.4(KitKat)上的Android Gallery为Intent返回不同的URI。ACTION_GET_CONTENT


214

在KitKat之前(或在新Gallery之前)Intent.ACTION_GET_CONTENT返回了这样的URI

内容:// media / external / images / media / 3951。

使用ContentResolver和查询 MediaStore.Images.Media.DATA返回文件URL。

但是,在KitKat中,图库会返回URI(通过“ Last”),如下所示:

内容://com.android.providers.media.documents/document/image:3951

我该如何处理?


21
袖手旁观,我会找到使用不需要直接访问文件的内容的方法。例如,Uri应该可以通过开启为流ContentResolver。我一直对应用程序感到紧张,这些应用程序假设content:// Uri代表文件的a总是可以转换为File
CommonsWare 2013年

1
@CommonsWare,如果我想将图像路径保存在sqlite db中以便以后打开,我应该保存URI还是绝对文件路径?
Snake 2013年

2
@CommonsWare我同意你的紧张态度。:-)但是,我需要能够将文件名(用于图像)传递给本机代码。一种解决方案是使用获得的数据复制InputStreamContentResolver给预先指定的地方,以便它具有已知的文件名。但是,这听起来很浪费我。还有其他建议吗?
darrenp 2014年

2
@darrenp:嗯...,重写本机代码以与InputStreamover JNI一起使用吗?不幸的是,您没有那么多选择。
CommonsWare 2014年

1
知道这很有用。感谢您的答复。从那以后,我发现我们现在将图像传递给内存中的C ++,而不是通过文件传递给C ++,因此我们现在可以使用InputStream而不是文件了(很棒)。仅EXIF标记读取有些棘手,需要Drew Noakes的library。非常感谢您的评论。
darrenp 2014年

Answers:


108

试试这个:

if (Build.VERSION.SDK_INT <19){
    Intent intent = new Intent(); 
    intent.setType("image/jpeg");
    intent.setAction(Intent.ACTION_GET_CONTENT);
    startActivityForResult(Intent.createChooser(intent, getResources().getString(R.string.select_picture)),GALLERY_INTENT_CALLED);
} else {
    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.setType("image/jpeg");
    startActivityForResult(intent, GALLERY_KITKAT_INTENT_CALLED);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (resultCode != Activity.RESULT_OK) return;
    if (null == data) return;
    Uri originalUri = null;
    if (requestCode == GALLERY_INTENT_CALLED) {
        originalUri = data.getData();
    } else if (requestCode == GALLERY_KITKAT_INTENT_CALLED) {
        originalUri = data.getData();
        final int takeFlags = data.getFlags()
                & (Intent.FLAG_GRANT_READ_URI_PERMISSION
                | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        // Check for the freshest data.
        getContentResolver().takePersistableUriPermission(originalUri, takeFlags);
    }

    loadSomeStreamAsynkTask(originalUri);

}

可能需要

@SuppressLint(“ NewApi”)

对于

takePersistableUriPermission


1
您介意详细说明KitKat代码在做什么吗?这需要任何新的许可吗?KitKat之前的代码也可以在KitKat上使用。那么,为什么我会选择对KitKat使用其他代码?谢谢。
Michael Greifeneder

67
看来我们无法从新的SDK URI获得路径。谷歌在没有适当的文件和公告的情况下进行了这种更改,这也是可耻的。
user65721

1
您能解释一下如何获取文件URL吗?我想在sdcard中获取真实路径。例如,如果是图片,我想获得此路径/storage/sdcard0/DCIM/Camera/IMG_20131118_153817_119.jpg而不是文档Uri。
阿尔瓦罗·

4
根据KitKat文档(developer.android.com/about/versions/…),除非OP确实打算使用/编辑其他应用程序拥有的文档,否则这可能不是OP所需要的。如果OP想要复制副本或以与旧版本一致的方式进行操作,则@voytez的答案会更合适。
Colin M.

8
这对我不起作用。我收到以下异常(库存4.4.2):E / AndroidRuntime(29204):由以下原因引起:java.lang.SecurityException:请求的标志为0x1,但仅允许使用0x0
Russell Stewart

177

这不需要特殊权限,并且可以与Storage Access Framework以及非官方ContentProvider模式(_data字段中的文件路径)一起使用。

/**
 * 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 context.
 * @param uri The Uri to query.
 * @author paulburke
 */
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];
            }

            // TODO handle non-primary volumes
        }
        // 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;
            }

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

/**
 * 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.
 */
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()) {
            final int index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(index);
        }
    } finally {
        if (cursor != null)
            cursor.close();
    }
    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());
}

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

在此处查看此方法的最新版本。


2
感谢Paul,在4.4 Nexus 5 Documents UI和其他使用标准Gallery应用程序的首选KitKat设备上,该功能效果非常好。
乔什(Josh)2013年

1
感谢这一点,我花了很长时间才达到sdk 19!我的问题是我的设备正在使用Google驱动器作为文件浏览器。如果文件位于设备映像路径上就可以了,但是如果文件位于驱动器上则无法打开。也许我只需要查看从Google Drive打开图像的处理。事情是我的应用程序被编写为使用文件路径并通过采样获取图像...
RuAware 2013年

2
@RuAware选择驱动器文件时,它会返回Authority: com.google.android.apps.docs.storageSegments: [document, acc=1;doc=667]。我不确定,但是假设该doc值是Uri您可以查询的ID。您可能需要按照以下“在Android上授权您的应用”中所述设置权限:developers.google.com/drive/integrate-android-ui。如果发现问题,请在这里更新。
Paul Burke 2013年

30
这绝对是可怕的!您不应继续传播“欺骗”这样的代码。它仅支持您知道其模式的源应用程序,而文档提供程序模型的重点是支持任意源
j__m 2014年

2
_data当ContentProvider不支持它时,它将不起作用。建议遵循@CommonsWare说明,不要再使用完整的文件路径,因为它可能是Dropbox云中的文件,而不是真实文件。
soshial

67

遇到相同的问题,请尝试上述解决方案,但尽管它通常可以正常工作,但由于某种原因,尽管我android.permission.MANAGE_DOCUMENTS正确添加了权限,但由于某些图像,我在Uri内容提供程序上拒绝了权限。

无论如何,找到了其他解决方案,该解决方案是使用以下方法强制打开图库,而不是打开KITKAT文档视图:

// KITKAT

i = new Intent(Intent.ACTION_PICK,android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
    startActivityForResult(i, CHOOSE_IMAGE_REQUEST);

然后加载图像:

Uri selectedImageURI = data.getData();
input = c.getContentResolver().openInputStream(selectedImageURI);
                BitmapFactory.decodeStream(input , null, opts);

编辑

ACTION_OPEN_DOCUMENT 可能需要您保留权限标志等,并且通常通常会导致安全异常...

其他解决方案是使用ACTION_GET_CONTENT结合使用的解决方案,该组合c.getContentResolver().openInputStream(selectedImageURI)将在KK之前和KK上都可以使用。Kitkat随后将使用新的文档视图,并且该解决方案将与所有应用程序一起使用,例如照片,图库,文件资源管理器,Dropbox,Google云端硬盘等),但是请记住,使用此解决方案时,您必须在其中创建图像onActivityResult()并将其存储在以SD卡为例。在下次启动应用程序时从保存的uri重新创建此图像会在内容解析器上引发安全异常,即使您按照Google API文档中的说明添加了权限标志(这就是我进行一些测试时所发生的情况)

此外,《 Android开发人员API指南》建议:

ACTION_OPEN_DOCUMENT不能替代ACTION_GET_CONTENT。您应该使用哪种应用取决于您的应用需求:

如果您希望您的应用仅读取/导入数据,请使用ACTION_GET_CONTENT。通过这种方法,应用程序可以导入数据的副本,例如图像文件。

如果您希望您的应用对文件提供者拥有的文件具有长期,持久的访问权限,请使用ACTION_OPEN_DOCUMENT。一个示例是照片编辑应用程序,该应用程序允许用户编辑存储在文档提供程序中的图像。


1
这个答案包含了适合我的正确信息。有条件地使用KitKat上的ACTION_PICK和EXTERNAL_CONTENT_URI提供了通过ContentResolver获取有关图库中图像的元数据的相同功能,就像使用旧版本的ACTION_GET_CONTENT一样。
Colin M.

@voytez,通过您的消息返回的URI是否可以转换为图像的完整真实路径?

我相信是这样,它应该像在KitKat之前一样工作,因为此代码强制打开图库而不是KK文档视图。但是,如果打算使用它来创建图像,则此解决方案会更好,因为转换为真实路径是多余的步骤。
voytez 2014年

4
也为我工作,而不是Intent.ACTION_GET_CONTENT。无论如何,我将Intent.createChooser()包装器保留在new上Intent,以使用户选择要浏览的应用程序,并按预期工作。有人可以看到此解决方案的缺点吗?
lorenzo-s 2014年


38

就像Commonsware提到的那样,您不应该假设通过获取的流可以ContentResolver转换为文件。

您真正应该做的是从中打开,然后InputStream从中ContentProvider创建一个位图。它也适用于4.4和更早的版本,无需反思。

    //cxt -> current context

    InputStream input;
    Bitmap bmp;
    try {
        input = cxt.getContentResolver().openInputStream(fileUri);
        bmp = BitmapFactory.decodeStream(input);
    } catch (FileNotFoundException e1) {

    }

当然,如果要处理大图像,则应使用适当的图像加载它们inSampleSizehttp : //developer.android.com/training/displaying-bitmaps/load-bitmap.html。但这是另一个话题。


不适用于运行Kitkat的Nexus 4,但适用于运行4.1.2的Galaxy S3
Dan2552 2013年

@ Dan2552哪一部分不起作用?你有什么例外吗?
米哈尔ķ

原来我对画廊使用了错误的意图调用。我使用的是用于任何类型文档的文件,但带有文件扩展名过滤器。
Dan2552 2013年

2
多么简单的答案,谢谢!对于遵循此答案的其他人,“ cxt”是指当前上下文,通常为“ this”。
thomasforth,2015年

1
这可能意味着该文件不存在。URI似乎正常。
米哈尔ķ

33

我相信已经发布的回应应该使人们朝着正确的方向前进。但是,对于我正在更新的旧代码,这就是我要做的事情。旧代码使用库中的URI进行更改,然后保存图像。

在4.4(和Google驱动器)之前,URI如下所示: content:// media / external / images / media / 41

如问题所述,它们通常看起来像这样: content://com.android.providers.media.documents/document/image:3951

由于我需要能够保存图像并且不打扰已经存在的代码,因此我仅将URI从图库复制到应用程序的数据文件夹中。然后从数据文件夹中保存的图像文件中产生一个新的URI。

这是主意:

Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
intent.setType("image/*");
startActivityForResult(intent), CHOOSE_IMAGE_REQUEST);

public void onActivityResult(int requestCode, int resultCode, Intent data) {

    super.onActivityResult(requestCode, resultCode, data);

    File tempFile = new File(this.getFilesDir().getAbsolutePath(), "temp_image");

    //Copy URI contents into temporary file.
    try {
        tempFile.createNewFile();
        copyAndClose(this.getContentResolver().openInputStream(data.getData()),new FileOutputStream(tempFile));
    }
    catch (IOException e) {
        //Log Error
    }

    //Now fetch the new URI
    Uri newUri = Uri.fromFile(tempFile);

    /* Use new URI object just like you used to */
 }

注意-copyAndClose()只是执行文件I / O,将InputStream复制到FileOutputStream中。该代码未发布。


相当聪明。我也需要实际的文件uri
较大的王

你是我的英雄,这正是我所需要的!对于谷歌云端硬盘文件的伟大工程,以及
米什金

开箱即用,对吗?:D此代码的工作原理与我期望的完全相同。
WeirdElfB0y 2015年

2
发布用于copyAndClose的代码,答案不完整
Bartek Pacia

24

只是想说这个答案很棒,我已经使用了很长时间没有问题。但是不久前,我偶然发现了一个问题,因为DownloadsProvider返回格式的URI content://com.android.providers.downloads.documents/document/raw%3A%2Fstorage%2Femulated%2F0%2FDownload%2Fdoc.pdf,因此应用崩溃了,NumberFormatException因为无法长时间解析其uri段。但是raw:segment包含可用于检索引用文件的直接uri。因此,我通过将isDownloadsDocument(uri) if内容替换为以下内容来修复了该问题:

final String id = DocumentsContract.getDocumentId(uri);
if (!TextUtils.isEmpty(id)) {
if (id.startsWith("raw:")) {
    return id.replaceFirst("raw:", "");
}
try {
    final Uri contentUri = ContentUris.withAppendedId(
            Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
    return getDataColumn(context, contentUri, null, null);
} catch (NumberFormatException e) {
    Log.e("FileUtils", "Downloads provider returned unexpected uri " + uri.toString(), e);
    return null;
}
}

2
完美的作品!谢谢
mikemike396 '18

8

我已经将多个答案组合到一个可以解决文件路径问题的有效解决方案中

哑剧类型与示例目的无关。

            Intent intent;
            if(Build.VERSION.SDK_INT >= 19){
                intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
                intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false);
                intent.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION);
            }else{
                intent = new Intent(Intent.ACTION_GET_CONTENT);
            }
            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            intent.setType("application/octet-stream");
            if(isAdded()){
                startActivityForResult(intent, RESULT_CODE);
            }

处理结果

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if( requestCode == RESULT_CODE && resultCode == Activity.RESULT_OK) {
        Uri uri = data.getData();
        if (uri != null && !uri.toString().isEmpty()) {
            if(Build.VERSION.SDK_INT >= 19){
                final int takeFlags = data.getFlags() & Intent.FLAG_GRANT_READ_URI_PERMISSION;
                //noinspection ResourceType
                getActivity().getContentResolver()
                        .takePersistableUriPermission(uri, takeFlags);
            }
            String filePath = FilePickUtils.getSmartFilePath(getActivity(), uri);
            // do what you need with it...
        }
    }
}

FilePickUtils

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;

public class FilePickUtils {
    private static String getPathDeprecated(Context ctx, Uri uri) {
        if( uri == null ) {
            return null;
        }
        String[] projection = { MediaStore.Images.Media.DATA };
        Cursor cursor = ctx.getContentResolver().query(uri, projection, null, null, null);
        if( cursor != null ){
            int column_index = cursor
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            cursor.moveToFirst();
            return cursor.getString(column_index);
        }
        return uri.getPath();
    }

    public static String getSmartFilePath(Context ctx, Uri uri){

        if (Build.VERSION.SDK_INT < 19) {
            return getPathDeprecated(ctx, uri);
        }
        return  FilePickUtils.getPath(ctx, uri);
    }

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

                // TODO handle non-primary volumes
            }
            // 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;
                }

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

    /**
     * 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.
     */
    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()) {
                final int column_index = cursor.getColumnIndexOrThrow(column);
                return cursor.getString(column_index);
            }
        } finally {
            if (cursor != null)
                cursor.close();
        }
        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());
    }

}

我遇到了问题.... uri.getPath()返回带有/ external的uri,并且未返回路径。我添加了这个其他if(“ content” .equalsIgnoreCase(uri.getScheme()))块,现在效果很好..你能解释一下它的作用吗
FaisalAhmed

filePath正在为null。.在uri中:content://com.android.externalstorage.documents/document/799B-1419%3AScreenshot%2FScreenshot_20181117_162826.png
Bhavesh Moradiya

7

如何从URI获取实际的文件路径

回答

据我所知,我们不需要从URI获取文件路径,因为在大多数情况下,我们可以直接使用URI来完成工作(例如1.获取位图2.将文件发送到服务器等) )

1.发送到服务器

我们可以仅使用URI将文件直接发送到服务器。

使用URI,我们可以获得InputStream,可以使用MultiPartEntity直接将其发送到服务器。

/**
 * Used to form Multi Entity for a URI (URI pointing to some file, which we got from other application).
 *
 * @param uri     URI.
 * @param context Context.
 * @return Multi Part Entity.
 */
public MultipartEntity formMultiPartEntityForUri(final Uri uri, final Context context) {
    MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE, null, Charset.forName("UTF-8"));
    try {
        InputStream inputStream = mContext.getContentResolver().openInputStream(uri);
        if (inputStream != null) {
            ContentBody contentBody = new InputStreamBody(inputStream, getFileNameFromUri(uri, context));
            multipartEntity.addPart("[YOUR_KEY]", contentBody);
        }
    }
    catch (Exception exp) {
        Log.e("TAG", exp.getMessage());
    }
    return multipartEntity;
}

/**
 * Used to get a file name from a URI.
 *
 * @param uri     URI.
 * @param context Context.
 * @return File name from URI.
 */
public String getFileNameFromUri(final Uri uri, final Context context) {

    String fileName = null;
    if (uri != null) {
        // Get file name.
        // File Scheme.
        if (ContentResolver.SCHEME_FILE.equals(uri.getScheme())) {
            File file = new File(uri.getPath());
            fileName = file.getName();
        }
        // Content Scheme.
        else if (ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) {
            Cursor returnCursor =
                    context.getContentResolver().query(uri, null, null, null, null);
            if (returnCursor != null && returnCursor.moveToFirst()) {
                int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
                fileName = returnCursor.getString(nameIndex);
                returnCursor.close();
            }
        }
    }
    return fileName;
}

2.从URI获取BitMap

如果URI指向图像,则将获得位图,否则为null:

/**
 * Used to create bitmap for the given URI.
 * <p>
 * 1. Convert the given URI to bitmap.
 * 2. Calculate ratio (depending on bitmap size) on how much we need to subSample the original bitmap.
 * 3. Create bitmap bitmap depending on the ration from URI.
 * 4. Reference - http://stackoverflow.com/questions/3879992/how-to-get-bitmap-from-an-uri
 *
 * @param context       Context.
 * @param uri           URI to the file.
 * @param bitmapSize Bitmap size required in PX.
 * @return Bitmap bitmap created for the given URI.
 * @throws IOException
 */
public static Bitmap createBitmapFromUri(final Context context, Uri uri, final int bitmapSize) throws IOException {

    // 1. Convert the given URI to bitmap.
    InputStream input = context.getContentResolver().openInputStream(uri);
    BitmapFactory.Options onlyBoundsOptions = new BitmapFactory.Options();
    onlyBoundsOptions.inJustDecodeBounds = true;
    onlyBoundsOptions.inDither = true;//optional
    onlyBoundsOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;//optional
    BitmapFactory.decodeStream(input, null, onlyBoundsOptions);
    input.close();
    if ((onlyBoundsOptions.outWidth == -1) || (onlyBoundsOptions.outHeight == -1)) {
        return null;
    }

    // 2. Calculate ratio.
    int originalSize = (onlyBoundsOptions.outHeight > onlyBoundsOptions.outWidth) ? onlyBoundsOptions.outHeight : onlyBoundsOptions.outWidth;
    double ratio = (originalSize > bitmapSize) ? (originalSize / bitmapSize) : 1.0;

    // 3. Create bitmap.
    BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
    bitmapOptions.inSampleSize = getPowerOfTwoForSampleRatio(ratio);
    bitmapOptions.inDither = true;//optional
    bitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;//optional
    input = context.getContentResolver().openInputStream(uri);
    Bitmap bitmap = BitmapFactory.decodeStream(input, null, bitmapOptions);
    input.close();

    return bitmap;
}

/**
 * For Bitmap option inSampleSize - We need to give value in power of two.
 *
 * @param ratio Ratio to be rounded of to power of two.
 * @return Ratio rounded of to nearest power of two.
 */
private static int getPowerOfTwoForSampleRatio(final double ratio) {
    int k = Integer.highestOneBit((int) Math.floor(ratio));
    if (k == 0) return 1;
    else return k;
}

注释

  1. Android没有提供任何方法来从URI获取文件路径,并且在上述大多数答案中,我们已经硬编码了一些常量,这些常量可能会在功能发布时中断(对不起,我可能错了)。
  2. 在直接进入从URI获取文件路径的解决方案之前,请尝试是否可以通过URI和Android默认方法解决用例。

参考

  1. https://developer.android.com/guide/topics/providers/content-provider-basics.html
  2. https://developer.android.com/reference/android/content/ContentResolver.html
  3. https://hc.apache.org/httpcomponents-client-ga/httpmime/apidocs/org/apache/http/entity/mime/content/InputStreamBody.html

谢谢。在处理文件时,以这种方式使用Uri和ContentResolver可以大大简化我的应用程序。
jacksonakj16年


3

对于仍然在Android SDK 23及更高版本上使用@Paul Burke的代码的用户,如果您的项目遇到错误,说明您缺少EXTERNAL_PERMISSION,并且您确定已在AndroidManifest.xml文件中添加了用户权限。这是因为您可能使用的是Android API 23或更高版本,而Google则有必要在执行操作以在运行时访问文件时再次保证权限。

这意味着:如果您的SDK版本为23或更高版本,则在选择图片文件并希望知道其URI时,系统会要求您提供READ&WRITE权限。

除Paul Burke的解决方案外,以下是我的代码。我添加了这些代码,我的项目开始正常工作。

private static final int REQUEST_EXTERNAL_STORAGE = 1;
private static final String[] PERMISSINOS_STORAGE = {
    Manifest.permission.READ_EXTERNAL_STORAGE,
    Manifest.permission.WRITE_EXTERNAL_STORAGE
};

public static void verifyStoragePermissions(Activity activity) {
    int permission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE);

    if (permission != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(
                activity,
                PERMISSINOS_STORAGE,
                REQUEST_EXTERNAL_STORAGE
        );
    }
}

在您要求URI的活动和片段中:

private void pickPhotoFromGallery() {

    CompatUtils.verifyStoragePermissions(this);
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType("image/*");
    // startActivityForResult(intent, REQUEST_PHOTO_LIBRARY);
    startActivityForResult(Intent.createChooser(intent, "选择照片"),
            REQUEST_PHOTO_LIBRARY);
}

就我而言,我在CompatUtils.java定义了verifyStoragePermissions方法(作为静态类型,因此我可以在其他活动中调用它)。

同样,如果在调用verifyStoragePermissions方法之前先进行if状态以查看当前SDK版本是否高于23,则应该更有意义。


2

这是我的工作:

Uri selectedImageURI = data.getData();    imageFile = new File(getRealPathFromURI(selectedImageURI)); 

private String getRealPathFromURI(Uri contentURI) {
  Cursor cursor = getContentResolver().query(contentURI, null, null, null, null);
  if (cursor == null) { // Source is Dropbox or other similar local file path
      return contentURI.getPath();
      } else { 
      cursor.moveToFirst(); 
      int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA); 
      return cursor.getString(idx); 
  }
}

注意:managedQuery()方法已过时,因此我不使用它。

这个答案来自m3n0R上的问题android通过Uri.getPath()获取真实路径,我不承认任何信誉。我只是以为尚未解决此问题的人可以使用此功能。


2
这不是KitKat上新的Gallery应用程序(严格来说是“ Media Documents Provider”应用程序)的答案。
nagoya0 2014年

发问者称为“图库”的应用可能是kitkat上的新文件选择器。FYI:addictivetips.com/android/...
nagoya0

我做了类似的操作,并在Nexus 5X,Android 6上获得了IndexOutOfBound:cursor.getString(idx);
Osify

1

请尝试避免使用takePersistableUriPermission方法,因为它为我引发了运行时异常。/ ** *从图库中选择。* /

public void selectFromGallery() {
    if (Build.VERSION.SDK_INT < AppConstants.KITKAT_API_VERSION) {

        Intent intent = new Intent(); 
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        ((Activity)mCalledContext).startActivityForResult(intent,AppConstants.GALLERY_INTENT_CALLED);

    } else {

        Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
        intent.setType("image/*");
        ((Activity)mCalledContext).startActivityForResult(intent, AppConstants.GALLERY_AFTER_KITKAT_INTENT_CALLED);
    }
}

OnActivity用于处理图像数据的结果:

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

    //gallery intent result handling before kit-kat version
    if(requestCode==AppConstants.GALLERY_INTENT_CALLED 
            && resultCode == RESULT_OK) {

        Uri selectedImage = data.getData();
        String[] filePathColumn = {MediaStore.Images.Media.DATA};
        Cursor cursor = getContentResolver().query(selectedImage,filePathColumn, null, null, null);
        cursor.moveToFirst();
        int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
        String filePath = cursor.getString(columnIndex);
        cursor.close();
        photoFile = new File(filePath);
        mImgCropping.startCropImage(photoFile,AppConstants.REQUEST_IMAGE_CROP);

    }
    //gallery intent result handling after kit-kat version
    else if (requestCode == AppConstants.GALLERY_AFTER_KITKAT_INTENT_CALLED 
            && resultCode == RESULT_OK) {

        Uri selectedImage = data.getData();
        InputStream input = null;
        OutputStream output = null;

        try {
            //converting the input stream into file to crop the 
            //selected image from sd-card.
            input = getApplicationContext().getContentResolver().openInputStream(selectedImage);
            try {
                photoFile = mImgCropping.createImageFile();
            } catch (IOException e) {
                e.printStackTrace();
            }catch(Exception e) {
                e.printStackTrace();
            }
            output = new FileOutputStream(photoFile);

            int read = 0;
            byte[] bytes = new byte[1024];

            while ((read = input.read(bytes)) != -1) {
                try {
                    output.write(bytes, 0, read);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

在第二种情况下,您在哪里显示图像?
Quantum_VC 2015年

抱歉,如果mImgCropping.startCropImage(photoFile,AppConstants.REQUEST_IMAGE_CROP),我无法在其他地方添加此代码行;再次需要根据我的项目需要调用imagecropping函数
saranya

photoFile和mImgCropping是什么文件类型?
菲利普BH 2015年

1

如果有人感兴趣,我为以下项目制作了可工作的Kotlin版本ACTION_GET_CONTENT

var path: String = uri.path // uri = any content Uri
val databaseUri: Uri
val selection: String?
val selectionArgs: Array<String>?
if (path.contains("/document/image:")) { // files selected from "Documents"
    databaseUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
    selection = "_id=?"
    selectionArgs = arrayOf(DocumentsContract.getDocumentId(uri).split(":")[1])
} else { // files selected from all other sources, especially on Samsung devices
    databaseUri = uri
    selection = null
    selectionArgs = null
}
try {
    val projection = arrayOf(MediaStore.Images.Media.DATA,
        MediaStore.Images.Media._ID,
        MediaStore.Images.Media.ORIENTATION,
        MediaStore.Images.Media.DATE_TAKEN) // some example data you can query
    val cursor = context.contentResolver.query(databaseUri,
        projection, selection, selectionArgs, null)
    if (cursor.moveToFirst()) {
        // do whatever you like with the data
    }
    cursor.close()
} catch (e: Exception) {
    Log.e(TAG, e.message, e)
}

我只想要Kotlin的工作代码。对我来说有用。感谢
Harvi Sirja '19

1

我已经在这里尝试了几种答案,并且我认为我有一个可以每次都起作用并且还可以管理权限的解决方案。

它基于LEO的巧妙解决方案。这篇文章应该包含完成这项工作所需的所有代码,并且应该适用于任何手机和Android版本;)

为了能够从SD卡中选取文件,您需要在清单中添加以下文件:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

常数:

private static final int PICK_IMAGE = 456; // Whatever number you like
public static final int MY_PERMISSIONS_REQUEST_READ_EXTERNAL = 28528; // Whatever number you like
public static final String FILE_TEMP_NAME = "temp_image"; // Whatever file name you like

检查权限并在可能的情况下启动launchImagePick

if (ContextCompat.checkSelfPermission(getThis(),
        Manifest.permission.READ_EXTERNAL_STORAGE)
        != PackageManager.PERMISSION_GRANTED) {

    ActivityCompat.requestPermissions(getThis(),
            new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
            MY_PERMISSIONS_REQUEST_READ_EXTERNAL);
}
else {
    launchImagePick();
}

权限回应

@Override
public void onRequestPermissionsResult(int requestCode,
                                       @NonNull
                                         String permissions[],
                                       @NonNull
                                         int[] grantResults) {

    if (manageReadExternalPermissionResponse(this, requestCode, grantResults)) {
        launchImagePick();
    }
}

管理权限响应

public static boolean manageReadExternalPermissionResponse(final Activity activity, int requestCode, int[] grantResults) {

    if (requestCode == MY_PERMISSIONS_REQUEST_READ_EXTERNAL) {

        // If request is cancelled, the result arrays are empty.

        if (grantResults.length > 0
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

            // Permission was granted, yay! Do the
            // contacts-related task you need to do.
            return true;

        } else if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_DENIED) {

            boolean showRationale = ActivityCompat.shouldShowRequestPermissionRationale(activity,
                    Manifest.permission.READ_EXTERNAL_STORAGE);

            if (!showRationale) {
                // The user also CHECKED "never ask again".
                // You can either enable some fall back,
                // disable features of your app
                // or open another dialog explaining
                // again the permission and directing to
                // the app setting.

            } else {
                // The user did NOT check "never ask again".
                // This is a good place to explain the user
                // why you need the permission and ask if he/she wants
                // to accept it (the rationale).
            }
        } else {
            // Permission denied, boo! Disable the
            // functionality that depends on this permission.
        }
    }
    return false;
}

启动图像选择

private void launchImagePick() {

    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
    intent.setType("image/*");
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    startActivityForResult(intent, PICK_IMAGE);

    // see onActivityResult
}

管理图像选择响应

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == PICK_IMAGE) {

        if (resultCode == Activity.RESULT_OK) {
            if (data != null && data.getData() != null) {

                try {
                     InputStream inputStream = getContentResolver().openInputStream(data.getData())
                     if (inputStream != null) {

                        // No special persmission needed to store the file like that
                        FileOutputStream fos = openFileOutput(FILE_TEMP_NAME, Context.MODE_PRIVATE);

                        final int BUFFER_SIZE = 1 << 10 << 3; // 8 KiB buffer
                        byte[] buffer = new byte[BUFFER_SIZE];
                        int bytesRead = -1;
                        while ((bytesRead = inputStream.read(buffer)) > -1) {
                            fos.write(buffer, 0, bytesRead);
                        }
                        inputStream.close();
                        fos.close();

                        File tempImageFile = new File(getFilesDir()+"/"+FILE_TEMP_NAME);

                        // Do whatever you want with the File

                        // Delete when not needed anymore
                        deleteFile(FILE_TEMP_NAME);
                    }
                }
                catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                // Error display
            }
        } else {
            // The user did not select any image
        }
    }
}

那是所有人。这对我所有的电话都有效。


0

这是一个完全的hack,但是这就是我所做的...

因此,在设置DocumentsProvider的过程中,我注意到示例代码(在getDocIdForFile第450行附近)基于文件相对于您赋予它的指定根目录的(唯一)路径为所选文档生成了唯一ID。您mBaseDir在第96行设置的内容)。

因此,URI最终看起来像:

content://com.example.provider/document/root:path/to/the/file

如文档所述,它仅假设一个根(在我的情况下是,Environment.getExternalStorageDirectory()但是您可以在其他地方使用...然后,它采用从根开始的文件路径,并使其成为唯一的ID,并以“ root:” 开头。)可以通过删除"/document/root:uri.getPath()中的“”部分来确定路径,并通过执行以下操作来创建实际的文件路径:

public void onActivityResult(int requestCode, int resultCode, Intent data) {
// check resultcodes and such, then...
uri = data.getData();
if (uri.getAuthority().equals("com.example.provider"))  {
    String path = Environment.getExternalStorageDirectory(0.toString()
                 .concat("/")
                 .concat(uri.getPath().substring("/document/root:".length())));
    doSomethingWithThePath(path); }
else {
    // another provider (maybe a cloud-based service such as GDrive)
    // created this uri.  So handle it, or don't.  You can allow specific
    // local filesystem providers, filter non-filesystem path results, etc.
}

我知道。这真可耻,但确实有效。同样,这依赖于您在应用程序中使用自己的文档提供程序来生成文档ID。

(此外,还有一种更好的方法来构建路径,即不假定“ /”是路径分隔符,等等。但是您知道了。)


要以更疯狂的想法回复自己-如果您的应用程序已经在处理file://来自外部文件选择器的意图,则还可以检查授权,如上例所示,以确保它来自您的自定义提供程序,如果可以,则可以还可以使用该路径file://使用提取的路径来“伪造”新的意图,然后StartActivity()让您的应用将其拾取。我知道,太糟糕了。
fattire

0

这对我来说很好:

else if(requestCode == GALLERY_ACTIVITY_NEW && resultCode == Activity.RESULT_OK)
{
    Uri uri = data.getData();
    Log.i(TAG, "old uri =  " + uri);
    dumpImageMetaData(uri);

    try {
        ParcelFileDescriptor parcelFileDescriptor =
                getContentResolver().openFileDescriptor(uri, "r");
        FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
        Log.i(TAG, "File descriptor " + fileDescriptor.toString());

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);

        options.inSampleSize =
           BitmapHelper.calculateInSampleSize(options,
                                              User.PICTURE_MAX_WIDTH_IN_PIXELS,
                                              User.PICTURE_MAX_HEIGHT_IN_PIXELS);
        options.inJustDecodeBounds = false;

        Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
        imageViewPic.setImageBitmap(bitmap);

        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
        // get byte array here
        byte[] picData = stream.toByteArray();
        ParseFile picFile = new ParseFile(picData);
        user.setProfilePicture(picFile);
    }
    catch(FileNotFoundException exc)
    {
        Log.i(TAG, "File not found: " + exc.toString());
    }
}

忘记dumpImageMetaData(uri); 没必要
Rafa 2015年

0

依靠保罗·伯克的答案由于大多数建议的“内置”函数返回的路径无法解析为文件,因此我在解决外部SD卡的URI路径时遇到许多问题。

但是,这是他/// TODO处理非主卷的方法

String resolvedPath = "";
File[] possibleExtSdComposites = context.getExternalFilesDirs(null);
for (File f : possibleExtSdComposites) {
    // Reset final path
    resolvedPath = "";

    // Construct list of folders
    ArrayList<String> extSdSplit = new ArrayList<>(Arrays.asList(f.getPath().split("/")));

    // Look for folder "<your_application_id>"
    int idx = extSdSplit.indexOf(BuildConfig.APPLICATION_ID);

    // ASSUMPTION: Expected to be found at depth 2 (in this case ExtSdCard's root is /storage/0000-0000/) - e.g. /storage/0000-0000/Android/data/<your_application_id>/files
    ArrayList<String> hierarchyList = new ArrayList<>(extSdSplit.subList(0, idx - 2));

    // Construct list containing full possible path to the file
    hierarchyList.add(tail);
    String possibleFilePath = TextUtils.join("/", hierarchyList);

    // If file is found --> success
    if (idx != -1 && new File(possibleFilePath).exists()) {
        resolvedPath = possibleFilePath;
        break;
    }
}

if (!resolvedPath.equals("")) {
    return resolvedPath;
} else {
    return null;
}

请注意,这取决于层次结构,而层次结构在每个电话制造商上可能都不同-我尚未对它们进行全部测试(到目前为止,它在Xperia Z3 API 23和Samsung Galaxy A3 API 23上都运行良好)。

请确认它是否在其他地方效果不佳。


-1

@paul burke的答案对于API级别19及以上的相机和图库图片均适用,但是如果您的Android项目的最低SDK设置为19以下,则此方法将不起作用,并且上面提到的某些答案对于图库和相机。好吧,我修改了@paul burke的代码,该代码适用于低于19的API级别。下面是代码。

public static String getPath(final Context context, final Uri uri) {

    final boolean isKitKat = Build.VERSION.SDK_INT >=
                             Build.VERSION_CODES.KITKAT;
    Log.i("URI",uri+"");
    String result = uri+"";

    // DocumentProvider
    // if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
    if (isKitKat && (result.contains("media.documents"))) {

        String[] ary = result.split("/");
        int length = ary.length;
        String imgary = ary[length-1];
        final String[] dat = imgary.split("%3A");

        final String docId = dat[1];
        final String type = dat[0];

        Uri contentUri = null;
        if ("image".equals(type)) {
            contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
        }
        else if ("video".equals(type)) {
        }
        else if ("audio".equals(type)) {
        }

        final String selection = "_id=?";
        final String[] selectionArgs = new String[] {
            dat[1]
        };

        return getDataColumn(context, contentUri, selection, selectionArgs);
    }
    else
    if ("content".equalsIgnoreCase(uri.getScheme())) {
        return getDataColumn(context, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

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()) {
            final int column_index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(column_index);
        }
    }
    finally {
        if (cursor != null)
            cursor.close();
    }
    return null;
}

我收到java.lang.IllegalArgumentException:选择Google Doc图像时无法提供任何请求的列
dirkoneill 2016年

@dirkoneill我得到同样的异常。您找到解决办法了吗?
亨利

-4

问题的答案是您需要具有权限。在manifest.xml文件中键入以下代码:

<uses-sdk  android:minSdkVersion="8"   android:targetSdkVersion="18" />
<uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
<uses-permission android:name="android.permission.WRITE_OWNER_DATA"></uses-permission>
<uses-permission android:name="android.permission.READ_OWNER_DATA"></uses-permission>`

它对我有用...

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.