Làm cách nào để xác định loại MIME của tệp trong Android?

Giả sử tôi có một đường dẫn đầy đủ của tệp như: (/ sdcard / tlogo.png). Tôi muốn biết loại mime của nó.

Tôi đã tạo một chức năng cho nó

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

nhưng khi tôi gọi nó, nó trả về null.

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

Đầu tiên và quan trọng nhất, bạn nên xem xét việc gọi MimeTypeMap#getMimeTypeFromExtension(), như thế này:

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

Phát hiện loại mime của bất kỳ tập tin

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

Giải pháp MimeTypeMap ở trên trả về null trong cách sử dụng của tôi. Điều này hoạt động, và dễ dàng hơn:

Uri uri = Uri.fromFile(file);
ContentResolver cR = context.getContentResolver();
String mime = cR.getType(uri);

Phiên bản tối ưu hóa câu trả lời của Jens với loại không an toàn và loại dự phòng.

@NonNull
static String getMimeType(@NonNull File file) {
    String type = null;
    final String url = file.toString();
    final String 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;
}

Quan trọng : getFileExtensionFromUrl () chỉ hoạt động với chữ thường !

Cập nhật (19.03.2018)

Phần thưởng: Các phương thức trên như một chức năng mở rộng Kotlin ít dài dòng hơn :

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

File file = new File(path, name);

    MimeTypeMap mime = MimeTypeMap.getSingleton();
    int index = file.getName().lastIndexOf('.')+1;
    String ext = file.getName().substring(index).toLowerCase();
    String type = mime.getMimeTypeFromExtension(ext);

    intent.setDataAndType(Uri.fromFile(file), type);
    try
    {
      context.startActivity(intent);
    }
    catch(ActivityNotFoundException ex)
    {
        ex.printStackTrace();

    }

Đặc biệt chú ý đến giải pháp của umerk44 ở trên. gọi và là CASE SENSITIVE. Tôi đã dành một buổi chiều về điều này sau đó xem xét kỹ hơn - sẽ trở lại nếu bạn vượt qua "JPG" trong khi nó sẽ trả về "hình ảnh / jpeg" nếu bạn vượt qua "jpg".getMimeTypeFromExtensionguessMimeTypeTypeFromExtensiongetMimeTypeFromExtensionNULL

Đây là giải pháp mà tôi đã sử dụng trong ứng dụng Android của mình:

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

Đôi khi câu trả lời của Jeb và Jens không hoạt động và trả về null. Trong trường hợp này tôi sử dụng theo giải pháp. Đầu tệp thường chứa chữ ký loại. Tôi đọc nó và so sánh với được biết trong danh sách chữ ký .

/**
 *
 * @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];
    StringBuilder builder = new StringBuilder();
    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;
}

signatureIdlà một chỉ số của chữ ký trong mảng chữ ký. Ví dụ,

private static final int[] SIGNATURE_PNG = hexStringToIntArray("89504E470D0A1A0A");
private static final int[] SIGNATURE_JPEG = hexStringToIntArray("FFD8FF");
private static final int[] SIGNATURE_GIF = hexStringToIntArray("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;
}

Bây giờ tôi có loại tệp ngay cả khi URI của tệp không có. Tiếp theo tôi nhận được loại mime theo loại tập tin. Nếu bạn không biết loại mime nào sẽ nhận được, bạn có thể tìm thấy thích hợp trong bảng này .

Nó hoạt động cho rất nhiều loại tập tin. Nhưng đối với video thì nó không hoạt động, bởi vì bạn cần phải biết codec video để có được loại mime. Để có được loại mime của video, tôi sử dụng MediaMetadataRetriever .

Tôi đã cố gắng sử dụng các phương pháp tiêu chuẩn để xác định loại mime, nhưng tôi không thể giữ lại phần mở rộng tập tin bằng cách sử dụng MimeTypeMap.getFileExtensionFromUrl(uri.getPath()). Phương thức này trả về cho tôi một chuỗi rỗng. Vì vậy, tôi đã thực hiện một giải pháp không tầm thường để giữ lại phần mở rộng tập tin.

Đây là phương thức trả về phần mở rộng tập tin:

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

Và đã giữ lại phần mở rộng tập tin, có thể lấy loại mime như dưới đây:

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

MimeTypeMapcó thể không nhận ra một số phần mở rộng tệp như flv, mpeg, 3gpp, cpp. Vì vậy, bạn cần nghĩ cách mở rộng MimeTypeMap để duy trì mã của mình. Đây là một ví dụ như vậy.

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

Thêm vào đó, đây là một danh sách đầy đủ các loại mime

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

Dành cho Xamarin Android (Từ câu trả lời của @ HoaLe ở trên)

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

get file object....
File file = new File(filePath);

then....pass as a parameter to...

getMimeType(file);

...here is 


public String getMimeType(File file) {
        String mimetype = MimeTypeMap.getSingleton().getMimeTypeFromExtension(MimeTypeMap.getFileExtensionFromUrl(Uri.fromFile(file).toString()).toLowerCase());
        if (mimetype == null) {
            return "*/*";
        }
        return mimetype;///return the mimeType
    }

Trong khi từ tài sản / tệp (Lưu ý rằng một vài trường hợp bị thiếu trong MimeTypeMap).

private String getMimeType(String path) {
    if (null == path) return "*/*";

    String extension = path;
    int lastDot = extension.lastIndexOf('.');
    if (lastDot != -1) {
        extension = extension.substring(lastDot + 1);
    }

    // Convert the URI string 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);
}

Trong khi sử dụng ContentResolver

contentResolver.getType(uri)

Trong khi yêu cầu http / https

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

// This will return the mimeType. 
// for eg. xyz.png it will return image/png. 
// here uri is the file that we were picked using intent from ext/internal storage.
private String getMimeType(Uri uri) {
   // This class provides applications access to the content model.  
   ContentResolver contentResolver = getContentResolver();

   // getType(Uri url)-Return the MIME type of the given content URL. 
   return contentResolver.getType(uri);
}

Tôi phải đối mặt với vấn đề tương tự. Cho đến nay tôi biết kết quả có thể khác nhau cho các tên khác nhau, vì vậy cuối cùng đã đến với giải pháp này.

public String getMimeType(String filePath) {
    String type = null;
    String extension = null;
    int i = filePath.lastIndexOf('.');
    if (i > 0)
        extension = filePath.substring(i+1);
    if (extension != null)
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    return type;
}  

Giải pháp trên đã trả về null trong trường hợp tệp .rar, sử dụng URLConnection.guessContentTypeFromName (url) hoạt động trong trường hợp này.

mime từ tập tin địa phương:

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

bạn có nhiều lựa chọn để mở rộng tập tin: như: 1- String filename = uri.getLastPathSegment();xem liên kết này

2-bạn cũng có thể sử dụng mã này

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

nhưng điều này không tốt 3-nếu bạn có URI của tệp thì hãy sử dụng Mã này

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

4-nếu bạn có URL thì hãy sử dụng mã này:

 public static String getMimeType(String url) {
String type = null;
String extension = MimeTypeMap.getFileExtensionFromUrl(url);
if (extension != null) { 


  type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

return type;
}

thưởng thức mã của bạn :)

// new processing the mime type out of Uri which may return null in some cases
String 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 String getFileType(Uri file)
{
    try
    {
        if (file.getScheme().equals(ContentResolver.SCHEME_CONTENT))
            return subStringFromLastMark(SystemMaster.getContentResolver().getType(file), "/");
        else
            return MimeTypeMap.getFileExtensionFromUrl(file.toString()).toLowerCase();
    }
    catch(Exception e)
    {
        return null;
    }
}

public static String getMimeType(Uri file)
{
    try
    {
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(getFileType(file));
    }
    catch(Exception e)
    {
        return null;
    }
}

public static String subStringFromLastMark(String str,String mark)
{
    int l = str.lastIndexOf(mark);
    int end = str.length();
    if(l == -1)
        return str;

    return str.substring(l + 1, end);
}

Cũng đã trả về giá trị null trong đường dẫn trường hợp của tôi là

/ lưu trữ / giả lập / 0 / Âm nhạc / 01 - Ghost trên sàn nhảy.mp3

như công việc xung quanh sử dụng

val url = inUrl.replace ("", "")

vì vậy phương pháp trông giống như

@JvmStatic
    fun getMimeType(inUrl: String?): String {
        if (inUrl == null) return ""

        val url = inUrl.replace(" ","")
        var type: String? = 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
    }

kết quả là nó trả về kết quả thành công:

âm thanh / mpeg

Hy vọng nó sẽ giúp được ai

Không có câu trả lời nào ở đây là hoàn hảo. Dưới đây là câu trả lời kết hợp các yếu tố tốt nhất của tất cả các câu trả lời hàng đầu:

public final class FileUtil {

    // By default, Android doesn't provide support for JSON
    public static final String MIME_TYPE_JSON = "application/json";

    @Nullable
    public static String getMimeType(@NonNull Context context, @NonNull Uri uri) {

        String mimeType = null;
        if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
            ContentResolver cr = context.getContentResolver();
            mimeType = cr.getType(uri);
        } else {
            String fileExtension = getExtension(uri.toString());

            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 String getExtension(@Nullable String 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.substring(i+1, fileName.length());
            }
        }
        return null;
    }

    @Nullable
    private static String handleMiscFileExtensions(@NonNull String extension){

        if(extension.equals("json")){
            return MIME_TYPE_JSON;
        }
        else{
            return null;
        }
    }
}

Intent myIntent = new Intent(android.content.Intent.ACTION_VIEW);
                        File file = new File(filePatch); 
                        Uri uris = Uri.fromFile(file);
                        String mimetype = null;
                        if 
(uris.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
                            ContentResolver cr = 
getApplicationContext().getContentResolver();
                            mimetype = cr.getType(uris);
                        } else {
                            String fileExtension = 
MimeTypeMap.getFileExtensionFromUrl(uris.toString());
mimetype =  MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension.toLowerCase());
                        }

Tôi xem xét cách dễ nhất là tham khảo tệp Tài nguyên này: https://android.googlesource.com/pl platform / libcore / + / master / luni / src / main / java / libcore / net / android.mime.types

Tôi không nhận ra tại sao MimeTypeMap.getFileExtensionFromUrl()có vấn đề với spaces và một số ký tự khác, điều đó trả về "", nhưng tôi chỉ viết phương thức này để thay đổi tên tệp thành tên có thể thừa nhận. Nó chỉ chơi với Strings. Tuy nhiên, đó là loại công trình. Thông qua phương thức, các spaces hiện có trong tên tệp được biến thành một ký tự mong muốn (mà ở đây là "x") thông qua replaceAll(" ", "x")và các ký tự không phù hợp khác được chuyển thành một ký tự phù hợp thông qua URLEncoder. vì vậy cách sử dụng (theo các mã được trình bày trong câu hỏi và câu trả lời được chọn) nên giống như vậy getMimeType(reviseUrl(url)).

private String reviseUrl(String url) {

        String revisedUrl = "";
        int fileNameBeginning = url.lastIndexOf("/");
        int fileNameEnding = url.lastIndexOf(".");

        String cutFileNameFromUrl = url.substring(fileNameBeginning + 1, fileNameEnding).replaceAll(" ", "x");

        revisedUrl = url.
                substring(0, fileNameBeginning + 1) +
                java.net.URLEncoder.encode(cutFileNameFromUrl) +
                url.substring(fileNameEnding, url.length());

        return revisedUrl;
    }