Android: ottenere un URI di file da un URI di contenuto?

Nella mia app l'utente deve selezionare un file audio che l'app quindi gestisce. Il problema è che, affinché l'app faccia quello che voglio che faccia con i file audio, ho bisogno che l'URI sia in formato file. Quando utilizzo il lettore musicale nativo di Android per cercare il file audio nell'app, l'URI è un URI contenuto, che assomiglia a questo:

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

Tuttavia, usando la popolare applicazione di file manager Astro, ottengo quanto segue:

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

Quest'ultimo è molto più accessibile per me con cui lavorare, ma ovviamente voglio che l'app abbia funzionalità con il file audio che l'utente sceglie indipendentemente dal programma che usano per sfogliare la loro collezione. Quindi la mia domanda è: c'è un modo per convertire l' content://URI di stile in un file://URI? Altrimenti, cosa mi consiglieresti di risolvere questo problema? Ecco il codice che richiama il selettore, come riferimento:

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

Faccio quanto segue con l'URI del contenuto:

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

Quindi fai alcune cose FileInputStream con detto file.

Basta usare getContentResolver().openInputStream(uri)per ottenere un InputStreamda un URI.

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

Questa è una vecchia risposta con il modo deprecato e confuso di superare alcuni punti di dolore risolutore di contenuti specifici. Prendilo con alcuni grossi granelli di sale e usa l'API openInputStream corretta, se possibile.

Puoi utilizzare Content Resolver per ottenere un file://percorso content://dall'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 disponi di un Uri di contenuto content://com.externalstorage..., puoi utilizzare questo metodo per ottenere il percorso assoluto di una cartella o di un file su Android 19 o versioni successive .

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

Puoi controllare che ogni parte di Uri stia usando println. I valori restituiti per la mia scheda SD e la memoria principale del dispositivo sono elencati di seguito. È possibile accedere ed eliminare se il file è in memoria ma non sono stato in grado di eliminare il file dalla scheda SD utilizzando questo metodo, solo leggere o aprire l'immagine usando questo percorso assoluto. Se hai trovato una soluzione da eliminare usando questo metodo, ti preghiamo di condividere. SCHEDA 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

MEMORIA PRINCIPALE

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 desideri ottenere Uri con file:///dopo aver utilizzato il percorso

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

Cercare di gestire l'URI con content: // schema chiamando ContentResolver.query()non è una buona soluzione. Su HTC Desire in esecuzione 4.2.2 è possibile ottenere NULL come risultato della query.

Perché non usare ContentResolver invece? https://stackoverflow.com/a/29141800/3205334

Le risposte ispirate sono Jason LaBrun e Darth Raven . Provare approcci a cui ho già risposto mi ha portato alla soluzione di seguito che può riguardare principalmente casi null del cursore e conversione dal contenuto: // al file: //

Per convertire il file, leggi e scrivi il file dall'uri guadagnato

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

Per ottenere l'uso del nome file, coprirà il caso null del cursore

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

Esiste una buona opzione per la conversione dal tipo MIME all'estensione del file

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

Cursore per ottenere il nome del file

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

Bene, sono in ritardo per rispondere, ma il mio codice è stato testato

controlla schema 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);
        }

Nella risposta sopra ho convertito il video uri in array di byte, ma non è correlato alla domanda, ho appena copiato il mio codice completo per mostrare l'utilizzo FileInputStreame InputStreampoiché entrambi funzionano allo stesso modo nel mio codice.

Ho usato il contesto variabile che è getActivity () nel mio frammento e in Activity è semplicemente ActivityName.this

context=getActivity(); // in Frammento

context=ActivityName.this;// in attività