Comment vérifier si la ressource pointée par Uri est disponible?

J'ai de la ressource (fichier de musique) souligné par des Uri. Comment puis-je vérifier s'il est disponible avant j'ai essayer de jouer avec MediaPlayer?

Son Uri est stocké dans la base de données, de sorte que lorsque le fichier est supprimé ou sur stockage externe qui est démonté, alors je viens d'obtenir exception lorsque j'appel MediaPlayer.prepare().

Dans la situation ci-dessus que je voudrais jouer systèmes de sonnerie par défaut. Je pourrais bien sûr faire qu'après que j'ai attraper exception ci-dessus, mais peut-être il ya une certaine solution plus élégante?

edit:
J'ai oublié de mentionner que les fichiers de musique d'Uri sont effectivement acquises à l'aide de RingtonePreference. Cela signifie que je peux obtenir Uri pointant vers sonnerie de Stockage Interne, de Stockage Externe ou à défaut les systèmes de sonnerie.

Uri exemples sont:

  • contenu://settings/system/sonnerie - pour choisir la sonnerie par défaut
  • contenu://media/internal/audio/media/60 - pour la sonnerie de Stockage Interne
  • contenu://media/externe/audio/media/192 - pour la sonnerie sur Stockage Externe

J'ai été heureux avec le projet de "nouveau Fichier(chemin d'accès).il existe() la méthode, comme il m'a sauvé d'mentionné exception, mais après un certain temps j'ai remarqué qu'il renvoie false pour l'ensemble de mes sonnerie choix...
D'autres idées?

Avez-vous obtenir ces URI à l'aide de RingtoneManager.getCursor()? Ma compréhension est que tout, le curseur retourne devrait être disponible...

OriginalL'auteur Koger | 2011-10-04

  1. 23

    La raison, la méthode proposée ne fonctionne pas c'est parce que vous êtes à l'aide de la ContentProvider URI plutôt que le chemin du fichier. Pour obtenir le chemin du fichier, vous devez utiliser un curseur pour obtenir le fichier.

    En supposant String contentUri est égal au contenu de URI comme content://media/external/audio/media/192

    ContentResolver cr = getContentResolver();
String[] projection = {MediaStore.MediaColumns.DATA}
Cursor cur = cr.query(Uri.parse(contentUri), projection, null, null, null);
if (cur != null) {
  if (cur.moveToFirst()) {
    String filePath = cur.getString(0);

    if (new File(filePath).exists()) {
      //do something if it exists
    } else {
      //File was not found
    }
  } else {
     //Uri was ok but no entry found. 
  }
  cur.close();
} else {
  //content Uri was invalid or some other error occurred 
}

    Je n'ai pas utilisé cette méthode avec des fichiers son ou de stockage interne, mais il devrait travail. La requête doit retourner une seule ligne, directement à votre fichier.

    Il fonctionne très bien, merci beaucoup. Après l'avoir testé, je peux dire que le cur==null en situation, où contentUri points de contenu sur débranché le disque externe, et "le Fichier n'existe pas", par exemple dans la situation, quand il est renommé (ou supprimé, je suppose)
    Malheureusement il ne fonctionne pas pour le contenu://settings/system/sonnerie Uri, mais c'est assez logique et je peux travailler autour de
    La projection dans mon exemple, est à la recherche d'MediaStore colonnes. Pour vérifier que vous avez besoin de faire une requête distincte pour les Paramètres Android fournisseur de contenu.
    J'ai trouvé un moyen de vérifier si elle est disponible, mais je ne suis pas sûr si c'est la meilleure façon: developer.android.com/reference/android/content/... . si elle réussit, vous fermez la inputStream et vous pouvez supposer que la sonnerie peut être utilisé (à moins que quelqu'un supprime le fichier juste avant de l'utiliser), et si pas, le fichier a probablement été supprimé de son tracé d'origine. l'obtention de la sonnerie de la RingtoneManager ne veut pas dire que vous pouvez l'utiliser, le fichier peut avoir été supprimé après qu'il a obtenu à la DB.
    Curseur cur = cr.query(Uri.parse(contentUri), la projection, null, null, null); jette l'autorisation refus d'exception.

    OriginalL'auteur DeeV

  2. 3

    De Kitkat vous le pouvez, et vous devez, persistent Uri que votre application utilise si nécessaire. Autant que je sache, il y a 128 URI limite tu peux persister par application, donc c'est à vous de maximiser l'utilisation de ces ressources.

    Personnellement, je ne le traite pas avec des chemins d'accès direct dans ce cas, mais plutôt de vérifier si persisté URI existe toujours, depuis quand ressource (un fichier est supprimé à partir d'un périphérique, votre application perd les droits à cette URI, donc, que l'enregistrement d'aussi simple que la suivante:

    getContext().getContentResolver().getPersistedUriPermissions().forEach( {element -> element.uri == yourUri});

    En attendant, vous n'aurez pas besoin de vérifier pour URI autorisations lorsqu'un appareil est en dessous de Kitkat niveau API.

    Généralement, lors de la lecture de fichiers à partir de l'Uri que vous allez utiliser ParcelFileDescriptor, donc il va jeter si aucun fichier n'est disponible que pour les URI, par conséquent, vous devriez envelopper avec try/catch bloc.

    Malheureusement, la javadoc de getPersistedUriPermissions() semble sous-entendre que seuls les Uri déjà pris avec takePersistableUriPermission(Uri, int) sont retournés, et cette liste n'est pas nécessairement mis à jour lorsqu'un ContentProvider supprime une ressource (mes tests sur Oreo porte ce cas d'utilisation).

    OriginalL'auteur Dragas

  3. 1

    Moi aussi j'avais ce problème, j'ai vraiment envie de vérifier si un Uri était disponible avant d'essayer de le charger, inutile défaillances qui finissent par remplir mon Crashlytics journaux.

    Depuis l'arrivée de la StorageAccessFramework (SAF), DocumentProviders, etc., traiter avec les Uri est devenue plus compliquée. C'est ce que j'ai finalement utilisé:

    fun yourFunction() {
val uriToLoad = ...
val validUris = contentResolver.persistedUriPermissions.map { uri }
if (isLoadable(uriToLoad, validUris) != UriLoadable.NO) {
//Attempt to load the uri
}
}
enum class UriLoadable {
YES, NO, MAYBE
}
fun isLoadable(uri: Uri, granted: List<Uri>): UriLoadable {
return when(uri.scheme) {
"content" -> {
if (DocumentsContract.isDocumentUri(this, uri))
if (documentUriExists(uri) && granted.contains(uri))
UriLoadable.YES
else
UriLoadable.NO
else //Content URI is not from a document provider
if (contentUriExists(uri))
UriLoadable.YES
else
UriLoadable.NO
}
"file" -> if (File(uri.path).exists()) UriLoadable.YES else UriLoadable.NO
//http, https, etc. No inexpensive way to test existence.
else -> UriLoadable.MAYBE
}
}
//All DocumentProviders should support the COLUMN_DOCUMENT_ID column
fun documentUriExists(uri: Uri): Boolean =
resolveUri(uri, DocumentsContract.Document.COLUMN_DOCUMENT_ID)
//All ContentProviders should support the BaseColumns._ID column
fun contentUriExists(uri: Uri): Boolean =
resolveUri(uri, BaseColumns._ID)
fun resolveUri(uri: Uri, column: String): Boolean {
val cursor = contentResolver.query(uri,
arrayOf(column), //Empty projections are bad for performance
null,
null,
null)
val result = cursor?.moveToFirst() ?: false
cursor?.close()
return result
}

    Si quelqu'un a plus d'élégance -- ou corriger -- alternative, merci de faire un commentaire.

    OriginalL'auteur jules

  4. -1

    Essayez d'une fonction comme:

    public static boolean checkURIResource(Context context, Uri uri) {
Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
return (cursor != null && cursor.moveToFirst());
}

    OriginalL'auteur nkmuturi