Android: obtenir un URI de fichier à partir d'un URI de contenu?

Dans mon application, l'utilisateur doit sélectionner un fichier audio que l'application gère ensuite. Le problème est que pour que l'application fasse ce que je veux qu'elle fasse avec les fichiers audio, j'ai besoin que l'URI soit au format de fichier. Lorsque j'utilise le lecteur de musique natif d'Android pour rechercher le fichier audio dans l'application, l'URI est un URI de contenu, qui ressemble à ceci:

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

Cependant, en utilisant la populaire application de gestion de fichiers Astro, j'obtiens ce qui suit:

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

Ce dernier est beaucoup plus accessible pour moi, mais bien sûr, je veux que l'application ait une fonctionnalité avec le fichier audio que l'utilisateur choisit, quel que soit le programme qu'il utilise pour parcourir sa collection. Ma question est donc la suivante: y a-t-il un moyen de convertir l' content://URI de style en file://URI? Sinon, que me recommanderiez-vous pour résoudre ce problème? Voici le code qui appelle le sélecteur, pour référence:

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

Je fais ce qui suit avec l'URI du contenu:

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

Ensuite, faites des trucs FileInputStream avec ledit fichier.

Utilisez simplement getContentResolver().openInputStream(uri)pour obtenir un à InputStreampartir d'un URI.

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

C'est une vieille réponse avec une manière obsolète et piratée de surmonter certains problèmes spécifiques du résolveur de contenu. Prenez-le avec d'énormes grains de sel et utilisez l'API openInputStream appropriée si possible.

Vous pouvez utiliser le résolveur de contenu pour obtenir un file://chemin à partir de l' 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);

Si vous avez un Uri de contenu avec, content://com.externalstorage...vous pouvez utiliser cette méthode pour obtenir le chemin absolu d'un dossier ou d'un fichier sur Android 19 ou supérieur .

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

Vous pouvez vérifier que chaque partie d'Uri utilise println. Les valeurs renvoyées pour ma carte SD et la mémoire principale de mon appareil sont répertoriées ci-dessous. Vous pouvez accéder et supprimer si le fichier est en mémoire mais je n'ai pas pu supprimer le fichier de la carte SD en utilisant cette méthode, ne lisez ou ouvrez l'image qu'en utilisant ce chemin absolu. Si vous avez trouvé une solution à supprimer en utilisant cette méthode, veuillez la partager. CARTE 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

MÉMOIRE 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

Si vous souhaitez obtenir Uri file:///après avoir utilisé le chemin

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

Essayer de gérer l'URI avec le schéma content: // en appelant ContentResolver.query()n'est pas une bonne solution. Sur HTC Desire exécutant 4.2.2, vous pourriez obtenir NULL comme résultat de la requête.

Pourquoi ne pas utiliser ContentResolver à la place? https://stackoverflow.com/a/29141800/3205334

Les réponses inspirées sont Jason LaBrun et Darth Raven . Essayer des approches déjà répondues m'a conduit à la solution ci-dessous qui peut principalement couvrir les cas nuls de curseur et la conversion de contenu: // en fichier: //

Pour convertir le fichier, lisez et écrivez le fichier à partir de l'URI gagné

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

Pour obtenir l'utilisation du nom de fichier, il couvrira la casse nulle du curseur

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

Il existe une bonne option pour convertir du type mime en extension de fichier

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

Curseur pour obtenir le nom du fichier

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

Eh bien je suis un peu en retard pour répondre, mais mon code est testé

vérifier le schéma de 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);
        }

Dans la réponse ci-dessus, j'ai converti l'URI de la vidéo en tableau d'octets, mais ce n'est pas lié à la question, je viens de copier mon code complet pour montrer l'utilisation de FileInputStreamet InputStreamcomme les deux fonctionnent de la même manière dans mon code.

J'ai utilisé le contexte variable qui est getActivity () dans mon Fragment et dans Activity, il s'agit simplement de ActivityName.

context=getActivity(); // en fragment

context=ActivityName.this;// en activité