Comment déterminer le type de fichier MIME dans Android?

Supposons que j’ai un chemin complet de fichier comme: (/ sdcard / tlogo.png). Je veux connaître son type de mime.

J’ai créé une fonction pour cela

public static Ssortingng getMimeType(File file, Context context) { Uri uri = Uri.fromFile(file); ContentResolver cR = context.getContentResolver(); MimeTypeMap mime = MimeTypeMap.getSingleton(); Ssortingng type = mime.getExtensionFromMimeType(cR.getType(uri)); return type; } 

mais quand je l’appelle, il renvoie null.

 File file = new File(filePath); Ssortingng fileType=CommonFunctions.getMimeType(file, context); 

Avant toute chose, vous devriez envisager d’appeler MimeTypeMap#getMimeTypeFromExtension() , comme ceci:

 // url = file path or whatever suitable URL you want. public static Ssortingng getMimeType(Ssortingng url) { Ssortingng type = null; Ssortingng extension = MimeTypeMap.getFileExtensionFromUrl(url); if (extension != null) { type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); } return type; } 

Détecter le type de mime de mon

 public Ssortingng getMimeType(Uri uri) { Ssortingng mimeType = null; if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) { ContentResolver cr = getAppContext().getContentResolver(); mimeType = cr.getType(uri); } else { Ssortingng fileExtension = MimeTypeMap.getFileExtensionFromUrl(uri .toSsortingng()); mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension( fileExtension.toLowerCase()); } return mimeType; } 

La solution MimeTypeMap ci-dessus est restée nulle dans mon utilisation. Cela fonctionne, et c’est plus facile:

 Uri uri = Uri.fromFile(file); ContentResolver cR = context.getContentResolver(); Ssortingng mime = cR.getType(uri); 
 File file = new File(path, name); MimeTypeMap mime = MimeTypeMap.getSingleton(); int index = file.getName().lastIndexOf('.')+1; Ssortingng ext = file.getName().subssortingng(index).toLowerCase(); Ssortingng type = mime.getMimeTypeFromExtension(ext); intent.setDataAndType(Uri.fromFile(file), type); try { context.startActivity(intent); } catch(ActivityNotFoundException ex) { ex.printStackTrace(); } 

Version optimisée de Jens ‘ Answere avec null-sécurité et le type de repli.

 @NonNull static Ssortingng getMimeType(@NonNull File file) { Ssortingng type = null; final Ssortingng url = file.toSsortingng(); final Ssortingng extension = MimeTypeMap.getFileExtensionFromUrl(url); if (extension != null) { type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase()); } if (type == null) { type = "image/*"; // fallback type. You might set it to */* } return type; } 

Important : getFileExtensionFromUrl () ne fonctionne qu’avec les minuscules !


Mise à jour (19.03.2018)

Bonus: méthodes ci-dessus en tant que fonction d’extension moins prolixe de Kotlin :

 fun File.getMimeType(fallback: Ssortingng = "image/*"): Ssortingng { return MimeTypeMap.getFileExtensionFromUrl(toSsortingng()) ?.apply { MimeTypeMap.getSingleton().getMimeTypeFromExtension(toLowerCase()) } ?: fallback // You might set it to */* } 

Portez une attention particulière à la solution d’ umerk44 ci-dessus. getMimeTypeFromExtension appelle guessMimeTypeTypeFromExtension et est CASE SENSITIVE. J’ai passé un après-midi là-dessus puis getMimeTypeFromExtension regardé de plus près – getMimeTypeFromExtension renverra NULL si vous le passez “JPG” alors qu’il renverra “image / jpeg” si vous le passez “jpg”.

Parfois, les réponses de Jeb et Jens ne fonctionnent pas et renvoient null. Dans ce cas, j’utilise la solution suivante. Head of file contient généralement une signature de type. Je le lis et le compare avec la liste des signatures connue.

 /** * * @param is InputStream on start of file. Otherwise signature can not be defined. * @return int id of signature or -1, if unknown signature was found. See SIGNATURE_ID_(type) constants to * identify signature by its id. * @throws IOException in cases of read errors. */ public static int getSignatureIdFromHeader(InputStream is) throws IOException { // read signature from head of source and compare with known signatures int signatureId = -1; int sigCount = SIGNATURES.length; int[] byteArray = new int[MAX_SIGNATURE_LENGTH]; SsortingngBuilder builder = new SsortingngBuilder(); for (int i = 0; i < MAX_SIGNATURE_LENGTH; i++) { byteArray[i] = is.read(); builder.append(Integer.toHexString(byteArray[i])); } if (DEBUG) { Log.d(TAG, "head bytes=" + builder.toString()); } for (int i = 0; i < MAX_SIGNATURE_LENGTH; i++) { // check each bytes with known signatures int bytes = byteArray[i]; int lastSigId = -1; int coincidences = 0; for (int j = 0; j < sigCount; j++) { int[] sig = SIGNATURES[j]; if (DEBUG) { Log.d(TAG, "compare" + i + ": " + Integer.toHexString(bytes) + " with " + sig[i]); } if (bytes == sig[i]) { lastSigId = j; coincidences++; } } // signature is unknown if (coincidences == 0) { break; } // if first bytes of signature is known we check signature for full coincidence if (coincidences == 1) { int[] sig = SIGNATURES[lastSigId]; int sigLength = sig.length; boolean isSigKnown = true; for (; i < MAX_SIGNATURE_LENGTH && i < sigLength; i++) { bytes = byteArray[i]; if (bytes != sig[i]) { isSigKnown = false; break; } } if (isSigKnown) { signatureId = lastSigId; } break; } } return signatureId; } 

signatureId est un index de signature dans un tableau de signatures. Par exemple,

 private static final int[] SIGNATURE_PNG = hexSsortingngToIntArray("89504E470D0A1A0A"); private static final int[] SIGNATURE_JPEG = hexSsortingngToIntArray("FFD8FF"); private static final int[] SIGNATURE_GIF = hexSsortingngToIntArray("474946"); public static final int SIGNATURE_ID_JPEG = 0; public static final int SIGNATURE_ID_PNG = 1; public static final int SIGNATURE_ID_GIF = 2; private static final int[][] SIGNATURES = new int[3][]; static { SIGNATURES[SIGNATURE_ID_JPEG] = SIGNATURE_JPEG; SIGNATURES[SIGNATURE_ID_PNG] = SIGNATURE_PNG; SIGNATURES[SIGNATURE_ID_GIF] = SIGNATURE_GIF; } 

Maintenant, j'ai le type de fichier même si l'URI du fichier n'a pas. Ensuite, j'obtiens le type mime par type de fichier. Si vous ne savez pas quel type de mime vous voulez obtenir, vous pouvez le trouver dans ce tableau .

Cela fonctionne pour beaucoup de types de fichiers. Mais pour la vidéo, cela ne fonctionne pas, car vous devez connaître le codec vidéo pour obtenir un type MIME. Pour obtenir le type MIME de la vidéo, j'utilise MediaMetadataResortingever .

Voici la solution que j’ai utilisée dans mon application Android:

 public static Ssortingng getMimeType(Ssortingng url) { Ssortingng extension = url.subssortingng(url.lastIndexOf(".")); Ssortingng mimeTypeMap = MimeTypeMap.getFileExtensionFromUrl(extension); Ssortingng mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(mimeTypeMap); return mimeType; } 

MimeTypeMap peut ne pas reconnaître certaines extensions de fichiers comme flv, mpeg, 3gpp, cpp. Donc, vous devez réfléchir à la façon de développer la MimeTypeMap pour conserver votre code. Voici un exemple.

http://grepcode.com/file/repo1.maven.org/maven2/com.google.okhttp/okhttp/20120626/libcore/net/MimeUtils.java#MimeUtils

De plus, voici une liste complète des types de mime

http: //www.sitepoint.com/web-foundations/mime-types-complete-list/

 get file object.... File file = new File(filePath); then....pass as a parameter to... getMimeType(file); ...here is public Ssortingng getMimeType(File file) { Ssortingng mimetype = MimeTypeMap.getSingleton().getMimeTypeFromExtension(MimeTypeMap.getFileExtensionFromUrl(Uri.fromFile(file).toSsortingng()).toLowerCase()); if (mimetype == null) { return "*/*"; } return mimetype;///return the mimeType } 

Alors que de l’actif / fichier (Notez que quelques cas manquants de la MimeTypeMap).

 private Ssortingng getMimeType(Ssortingng path) { if (null == path) return "*/*"; Ssortingng extension = path; int lastDot = extension.lastIndexOf('.'); if (lastDot != -1) { extension = extension.subssortingng(lastDot + 1); } // Convert the URI ssortingng to lower case to ensure compatibility with MimeTypeMap (see CB-2185). extension = extension.toLowerCase(Locale.getDefault()); if (extension.equals("3ga")) { return "audio/3gpp"; } else if (extension.equals("js")) { return "text/javascript"; } else if (extension.equals("woff")) { return "application/x-font-woff"; } else { // TODO // anyting missing from the map (http://www.sitepoint.com/web-foundations/mime-types-complete-list/) // reference: http://grepcode.com/file/repo1.maven.org/maven2/com.google.okhttp/okhttp/20120626/libcore/net/MimeUtils.java#MimeUtils } return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); } 

Bien utiliser ContentResolver

 contentResolver.getType(uri) 

Alors que la requête http / https

  try { HttpURLConnection conn = httpClient.open(new URL(uri.toSsortingng())); conn.setDoInput(false); conn.setRequestMethod("HEAD"); return conn.getHeaderField("Content-Type"); } catch (IOException e) { } 

J’ai essayé d’utiliser des méthodes standard pour déterminer le type MIME, mais je ne peux pas conserver l’extension de fichier à l’aide de MimeTypeMap.getFileExtensionFromUrl (uri.getPath ()). Cette méthode m’a renvoyé une chaîne vide. J’ai donc fait une solution non sortingviale pour conserver l’extension du fichier.

Voici la méthode renvoyant une extension de fichier

 private Ssortingng getExtention(Ssortingng fileName){ char[] arrayOfFilename = fileName.toCharArray(); for(int i = arrayOfFilename.length-1; i > 0; i--){ if(arrayOfFilename[i] == '.'){ return fileName.subssortingng(i+1, fileName.length()); } } return ""; } 

Et ayant conservé l’extention de fichier, il est possible d’obtenir le type MIME comme ci-dessous

 public Ssortingng getMimeType(File file) { Ssortingng mimeType = ""; Ssortingng extension = getExtention(file.getName()); if (MimeTypeMap.getSingleton().hasExtension(extension)) { mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); } return mimeType; } 

Pour Xamarin Android (réponse de @ HoaLe ci-dessus)

 public Ssortingng getMimeType(Uri uri) { Ssortingng mimeType = null; if (uri.Scheme.Equals(ContentResolver.SchemeContent)) { ContentResolver cr = Application.Context.ContentResolver; mimeType = cr.GetType(uri); } else { Ssortingng fileExtension = MimeTypeMap.GetFileExtensionFromUrl(uri.ToSsortingng()); mimeType = MimeTypeMap.Singleton.GetMimeTypeFromExtension( fileExtension.ToLower()); } return mimeType; } 

La solution ci-dessus a renvoyé la valeur null en cas de fichier .rar, en utilisant URLConnection.guessContentTypeFromName (url) dans ce cas.

mime du fichier local:

 Ssortingng url = file.getAbsolutePath(); FileNameMap fileNameMap = URLConnection.getFileNameMap(); Ssortingng mime = fileNameMap.getContentTypeFor("file://"+url); 

vous avez plusieurs choix pour obtenir une extension de fichier: comme: 1- Ssortingng filename = uri.getLastPathSegment(); voir ce lien

2-vous pouvez utiliser ce code aussi

  filePath .subssortingng(filePath.lastIndexOf(".")+1); 

mais ce n’est pas bon aproch. 3-si vous avez l’URI du fichier alors utilisez ce code

 Ssortingng[] projection = { MediaStore.MediaColumns.DATA, MediaStore.MediaColumns.MIME_TYPE }; 

4-si vous avez l’URL alors utilisez ce code:

  public static Ssortingng getMimeType(Ssortingng url) { Ssortingng type = null; Ssortingng extension = MimeTypeMap.getFileExtensionFromUrl(url); if (extension != null) { type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension); } return type; } 

profitez de votre code 🙂

 // new processing the mime type out of Uri which may return null in some cases Ssortingng mimeType = getContentResolver().getType(uri); // old processing the mime type out of path using the extension part if new way returned null if (mimeType == null){mimeType URLConnection.guessContentTypeFromName(path);} 
 public static Ssortingng getFileType(Uri file) { try { if (file.getScheme().equals(ContentResolver.SCHEME_CONTENT)) return subSsortingngFromLastMark(SystemMaster.getContentResolver().getType(file), "/"); else return MimeTypeMap.getFileExtensionFromUrl(file.toSsortingng()).toLowerCase(); } catch(Exception e) { return null; } } public static Ssortingng getMimeType(Uri file) { try { return MimeTypeMap.getSingleton().getMimeTypeFromExtension(getFileType(file)); } catch(Exception e) { return null; } } public static Ssortingng subSsortingngFromLastMark(Ssortingng str,Ssortingng mark) { int l = str.lastIndexOf(mark); int end = str.length(); if(l == -1) return str; return str.subssortingng(l + 1, end); } 

A également renvoyé une valeur nulle dans mon cas, le chemin était

/ storage / emulated / 0 / Musique / 01 – Ghost on the Dance Floor.mp3

comme travail autour de l’utilisation

val url = inUrl.replace (“”, “”)

donc la méthode ressemble à

 @JvmStatic fun getMimeType(inUrl: Ssortingng?): Ssortingng { if (inUrl == null) return "" val url = inUrl.replace(" ","") var type: Ssortingng? = null val extension = MimeTypeMap.getFileExtensionFromUrl(url) if (extension != null) { type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase()) } if(type ==null){ val cR = WifiTalkie.getApplicationContext().contentResolver type = cR.getType(Uri.parse(url)) } if (type == null) { type = "*/*" // fallback method_type. You might set it to */* } return type } 

en conséquence, le résultat est positif:

audio / mpeg

J’espère que ça aide quelqu’un

Aucune des réponses n’est parfaite. Voici une réponse combinant les meilleurs éléments de toutes les meilleures réponses:

 public final class FileUtil { // By default, Android doesn't provide support for JSON public static final Ssortingng MIME_TYPE_JSON = "application/json"; @Nullable public static Ssortingng getMimeType(@NonNull Context context, @NonNull Uri uri) { Ssortingng mimeType = null; if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) { ContentResolver cr = context.getContentResolver(); mimeType = cr.getType(uri); } else { Ssortingng fileExtension = getExtension(uri.toSsortingng()); if(fileExtension == null){ return null; } mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension( fileExtension.toLowerCase()); if(mimeType == null){ // Handle the misc file extensions return handleMiscFileExtensions(fileExtension); } } return mimeType; } @Nullable private static Ssortingng getExtension(@Nullable Ssortingng fileName){ if(fileName == null || TextUtils.isEmpty(fileName)){ return null; } char[] arrayOfFilename = fileName.toCharArray(); for(int i = arrayOfFilename.length-1; i > 0; i--){ if(arrayOfFilename[i] == '.'){ return fileName.subssortingng(i+1, fileName.length()); } } return null; } @Nullable private static Ssortingng handleMiscFileExtensions(@NonNull Ssortingng extension){ if(extension.equals("json")){ return MIME_TYPE_JSON; } else{ return null; } } }