Android: obtendo um URI de arquivo a partir de um URI de conteúdo?

No meu aplicativo, o usuário deve selecionar um arquivo de áudio que o aplicativo manipula. O problema é que, para que o aplicativo faça o que eu quero com os arquivos de áudio, preciso que o URI esteja no formato de arquivo. Quando uso o reprodutor de música nativo do Android para procurar o arquivo de áudio no aplicativo, o URI é um URI de conteúdo, com a seguinte aparência:

content://media/external/audio/media/710

No entanto, usando o popular aplicativo gerenciador de arquivos Astro, recebo o seguinte:

file:///sdcard/media/audio/ringtones/GetupGetOut.mp3

O último é muito mais acessível para eu trabalhar, mas é claro que eu quero que o aplicativo tenha funcionalidade com o arquivo de áudio que o usuário escolhe, independentemente do programa usado para navegar em sua coleção. Então, minha pergunta é: existe uma maneira de converter o content://estilo URI em um file://URI? Caso contrário, o que você recomendaria para eu resolver esse problema? Aqui está o código que chama o seletor, para referência:

Intent ringIntent = new Intent();
ringIntent.setType("audio/mp3");
ringIntent.setAction(Intent.ACTION_GET_CONTENT);
ringIntent.addCategory(Intent.CATEGORY_OPENABLE);
startActivityForResult(Intent.createChooser(ringIntent, "Select Ringtone"), SELECT_RINGTONE);

Eu faço o seguinte com o URI do conteúdo:

m_ringerPath = m_ringtoneUri.getPath();
File file = new File(m_ringerPath);

Em seguida, faça algumas coisas no FileInputStream com o referido arquivo.

Basta usar getContentResolver().openInputStream(uri)para obter um InputStreamde um URI.

http://developer.android.com/reference/android/content/ContentResolver.html#openInputStream(android.net.Uri)

Esta é uma resposta antiga, com uma maneira obsoleta e hacky de superar alguns pontos problemáticos específicos do resolvedor de conteúdo. Leve-o com grandes grãos de sal e use a API openInputStream adequada, se possível.

Você pode usar o resolvedor de conteúdo para obter um file://caminho a partir do content://URI:

String filePath = null;
Uri _uri = data.getData();
Log.d("","URI = "+ _uri);                                       
if (_uri != null && "content".equals(_uri.getScheme())) {
    Cursor cursor = this.getContentResolver().query(_uri, new String[] { android.provider.MediaStore.Images.ImageColumns.DATA }, null, null, null);
    cursor.moveToFirst();   
    filePath = cursor.getString(0);
    cursor.close();
} else {
    filePath = _uri.getPath();
}
Log.d("","Chosen path = "+ filePath);

Se você tiver um conteúdo Uri, content://com.externalstorage...poderá usar esse método para obter o caminho absoluto de uma pasta ou arquivo no Android 19 ou superior .

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)) {
        System.out.println("getPath() uri: " + uri.toString());
        System.out.println("getPath() uri authority: " + uri.getAuthority());
        System.out.println("getPath() uri path: " + uri.getPath());

        // ExternalStorageProvider
        if ("com.android.externalstorage.documents".equals(uri.getAuthority())) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];
            System.out.println("getPath() docId: " + docId + ", split: " + split.length + ", type: " + type);

            // This is for checking Main Memory
            if ("primary".equalsIgnoreCase(type)) {
                if (split.length > 1) {
                    return Environment.getExternalStorageDirectory() + "/" + split[1] + "/";
                } else {
                    return Environment.getExternalStorageDirectory() + "/";
                }
                // This is for checking SD Card
            } else {
                return "storage" + "/" + docId.replace(":", "/");
            }

        }
    }
    return null;
}

Você pode verificar se cada parte do Uri está usando println. Os valores retornados para o cartão SD e a memória principal do dispositivo estão listados abaixo. Você pode acessar e excluir se o arquivo estiver na memória, mas não foi possível excluir o arquivo do cartão SD usando esse método, apenas ler ou abrir uma imagem usando esse caminho absoluto. Se você encontrar uma solução para excluir usando esse método, compartilhe. CARTÃO SD

getPath() uri: content://com.android.externalstorage.documents/tree/612E-B7BF%3A/document/612E-B7BF%3A
getPath() uri authority: com.android.externalstorage.documents
getPath() uri path: /tree/612E-B7BF:/document/612E-B7BF:
getPath() docId: 612E-B7BF:, split: 1, type: 612E-B7BF

MEMÓRIA PRINCIPAL

getPath() uri: content://com.android.externalstorage.documents/tree/primary%3A/document/primary%3A
getPath() uri authority: com.android.externalstorage.documents
getPath() uri path: /tree/primary:/document/primary:
getPath() docId: primary:, split: 1, type: primary

Se você deseja obter Uri file:///depois de obter o caminho, use

DocumentFile documentFile = DocumentFile.fromFile(new File(path));
documentFile.getUri() // will return a Uri with file Uri

Tentar manipular o URI com o esquema content: // chamando ContentResolver.query()não é uma boa solução. No HTC Desire executando o 4.2.2, você pode obter NULL como resultado da consulta.

Por que não usar o ContentResolver? https://stackoverflow.com/a/29141800/3205334

Respostas inspiradas são Jason LaBrun e Darth Raven . Tentar abordagens já respondidas me levou à solução abaixo, que pode cobrir principalmente casos nulos do cursor e conversão de conteúdo: // para file: //

Para converter arquivos, leia e escreva o arquivo a partir de uri ganho

public static Uri getFilePathFromUri(Uri uri) throws IOException {
    String fileName = getFileName(uri);
    File file = new File(myContext.getExternalCacheDir(), fileName);
    file.createNewFile();
    try (OutputStream outputStream = new FileOutputStream(file);
         InputStream inputStream = myContext.getContentResolver().openInputStream(uri)) {
        FileUtil.copyStream(inputStream, outputStream); //Simply reads input to output stream
        outputStream.flush();
    }
    return Uri.fromFile(file);
}

Para obter o uso do nome do arquivo, ele cobrirá o caso nulo do cursor

public static String getFileName(Uri uri) {
    String fileName = getFileNameFromCursor(uri);
    if (fileName == null) {
        String fileExtension = getFileExtension(uri);
        fileName = "temp_file" + (fileExtension != null ? "." + fileExtension : "");
    } else if (!fileName.contains(".")) {
        String fileExtension = getFileExtension(uri);
        fileName = fileName + "." + fileExtension;
    }
    return fileName;
}

Há uma boa opção para converter do tipo MIME para extensão de arquivo

 public static String getFileExtension(Uri uri) {
    String fileType = myContext.getContentResolver().getType(uri);
    return MimeTypeMap.getSingleton().getExtensionFromMimeType(fileType);
}

Cursor para obter o nome do arquivo

public static String getFileNameFromCursor(Uri uri) {
    Cursor fileCursor = myContext.getContentResolver().query(uri, new String[]{OpenableColumns.DISPLAY_NAME}, null, null, null);
    String fileName = null;
    if (fileCursor != null && fileCursor.moveToFirst()) {
        int cIndex = fileCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
        if (cIndex != -1) {
            fileName = fileCursor.getString(cIndex);
        }
    }
    return fileName;
}

Bem, estou um pouco atrasado para responder, mas meu código é testado

esquema de verificação da uri:

 byte[] videoBytes;

if (uri.getScheme().equals("content")){
        InputStream iStream =   context.getContentResolver().openInputStream(uri);
            videoBytes = getBytes(iStream);
        }else{
            File file = new File(uri.getPath());
            FileInputStream fileInputStream = new FileInputStream(file);     
            videoBytes = getBytes(fileInputStream);
        }

Na resposta acima, converti a URL do vídeo para a matriz de bytes, mas isso não está relacionado à pergunta, apenas copiei meu código completo para mostrar o uso de FileInputStreameInputStream como ambos estão funcionando da mesma forma no meu código.

Eu usei o contexto variável que é getActivity () no meu fragmento e em Activity simplesmente é ActivityName.this

context=getActivity(); // no fragmento

context=ActivityName.this;// em atividade