Android MineType

概述

多用途互联网邮件扩展（MIME，Multipurpose Internet Mail Extensions）是一个互联网标准，它扩展了电子邮件标准，使其能够支持非ASCII字符、二进制格式附件等多种格式的邮件消息。

内容类型（Content-Type），这个头部领域用于指定消息的类型。一般以下面的形式出现:[type]/[subtype]

type有下面的形式:

Text：用于标准化地表示的文本信息，文本消息可以是多种字符集和或者多种格式的；

Multipart：用于连接消息体的多个部分构成一个消息，这些部分可以是不同类型的数据；

Application：用于传输应用程序数据或者二进制数据；
Message：用于包装一个E-mail消息；

Image：用于传输静态图片数据；
Audio：用于传输音频或者音声数据；

Video：用于传输动态影像数据，可以是与音频编辑在一起的视频数据格式。

subtype用于指定type的详细形式。content-type/subtype配对的集合和与此相关的参数，将随着时间而增长。为了确保这些值在一个有序而且公开的状态下开发，MIME使用Internet
Assigned Numbers Authority (IANA)作为中心的注册机制来管理这些值。

常用的subtype值如下所示：

text/plain（纯文本）
text/html（HTML文档）

application/xhtml+xml（XHTML文档）
image/gif（GIF图像）

image/jpeg（JPEG图像）【PHP中为：image/pjpeg】

image/png（PNG图像）【PHP中为：image/x-png】
video/mpeg（MPEG动画）

application/octet-stream（任意的二进制数据）
application/pdf（PDF文档）

application/msword（Microsoft Word文件）
message/rfc822（RFC 822形式）

multipart/alternative（HTML邮件的HTML形式和纯文本形式，相同内容使用不同形式表示）

application/x-www-form-urlencoded（使用HTTP的POST方法提交的表单）

multipart/form-data（同上，但主要用于表单提交时伴随文件上传的场合）

---

Android中MimeType的用途

Intent-Filter中的<data>有一个mimeType .
它的作用是告诉Android系统本Activity可以处理的文件的类型。如设置为 “text/plain”表示可以处理“.txt”文件。

MimeTypeMap类:是专门处理mimeType的类。

package android.webkit;

import android.text.TextUtils;
import java.util.regex.Pattern;
import libcore.net.MimeUtils;

public class MimeTypeMap {
    private static final MimeTypeMap sMimeTypeMap = new MimeTypeMap();

    private MimeTypeMap() {
    }

    public static String getFileExtensionFromUrl(String url) {
        if (!TextUtils.isEmpty(url)) {
            int fragment = url.lastIndexOf('#');
            if (fragment > 0) {
                url = url.substring(0, fragment);
            }

            int query = url.lastIndexOf('?');
            if (query > 0) {
                url = url.substring(0, query);
            }

            int filenamePos = url.lastIndexOf('/');
            String filename =
                0 <= filenamePos ? url.substring(filenamePos + 1) : url;

                if (!filename.isEmpty() &&
                Pattern.matches("[a-zA-Z_0-9\\.\\-\\(\\)\\%]+", filename)) {
                int dotPos = filename.lastIndexOf('.');
                if (0 <= dotPos) {
                    return filename.substring(dotPos + 1);
                }
            }
        }

        return "";
    }

    public boolean hasMimeType(String mimeType) {
        return MimeUtils.hasMimeType(mimeType);
    }

    public String getMimeTypeFromExtension(String extension) {
        return MimeUtils.guessMimeTypeFromExtension(extension);
    }

       private static String mimeTypeFromExtension(String extension) {
        return MimeUtils.guessMimeTypeFromExtension(extension);
    }

    public boolean hasExtension(String extension) {
        return MimeUtils.hasExtension(extension);
    }

    public String getExtensionFromMimeType(String mimeType) {
        return MimeUtils.guessExtensionFromMimeType(mimeType);
    }

    /* package */ String remapGenericMimeType(String mimeType, String url,
            String contentDisposition) {

        if ("text/plain".equals(mimeType) ||

            String filename = null;
            if (contentDisposition != null) {
                filename = URLUtil.parseContentDisposition(contentDisposition);
            }
            if (filename != null) {
                url = filename;
            }
            String extension = getFileExtensionFromUrl(url);
            String newMimeType = getMimeTypeFromExtension(extension);
            if (newMimeType != null) {
                mimeType = newMimeType;
            }
        } else if ("text/vnd.wap.wml".equals(mimeType)) {

            mimeType = "text/plain";
        } else {
                if ("application/vnd.wap.xhtml+xml".equals(mimeType)) {
                mimeType = "application/xhtml+xml";
            }
        }
        return mimeType;
    }

    public static MimeTypeMap getSingleton() {
        return sMimeTypeMap;
    }
}

MimeTypeMap类是单例模式的，既没有公有的构造方法。使用getSinglton()方法获得MimeTypeMap对象：

示例代码一:

MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
//MimeTypeMap中是否有txt的MimeType
System.out.println(mimeTypeMap.hasExtension("txt"));
System.out.println(mimeTypeMap.hasMimeType("text/html"));
//获得txt文件类型的MimeType
String extension = mimeTypeMap.getMimeTypeFromExtension("txt");
System.out.println(extension);

示例代码二:

private String getMIMEType(File file)

{

    String type = "*";

    String end = file.getName().substring(dotIndex, file.getName().length()).toLowerCase();

    if (end == "")
        return type;

    //在MIME和文件类型的匹配表中找到对应的MIME类型。 

    for (int i = 0; i < MIME_MapTable.length; i++) {

        if (end.equals(MIME_MapTable[i][0]))

            type = MIME_MapTable[i][1];

    }

    return type;

}

private void openFile(File file) {

    //Uri uri = Uri.parse("file://"+file.getAbsolutePath()); 

    Intent intent = new Intent();

    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

    //设置intent的Action属性 

    intent.setAction(Intent.ACTION_VIEW);

    //获取文件file的MIME类型 

    String type = getMIMEType(file);

    //设置intent的data和Type属性。 

    intent.setDataAndType(Uri.fromFile(file), type);

    //跳转 

    startActivity(intent);

}

private final String[][] MIME_MapTable = {

        //{后缀名， MIME类型} 

        {".3gp", "video/3gpp"},

        {".apk", "application/vnd.android.package-archive"},

        {".asf", "video/x-ms-asf"},

        {".avi", "video/x-msvideo"},

        {".bin", "application/octet-stream"},

        {".bmp", "image/bmp"},

        {".c", "text/plain"},

        {".class", "application/octet-stream"},

        {".conf", "text/plain"},

        {".cpp", "text/plain"},

        {".doc", "application/msword"},

        {".exe", "application/octet-stream"},

        {".gif", "image/gif"},

        {".gtar", "application/x-gtar"},

        {".gz", "application/x-gzip"},

        {".h", "text/plain"},

        {".htm", "text/html"},

        {".html", "text/html"},

        {".jar", "application/java-archive"},

        {".java", "text/plain"},

        {".jpeg", "image/jpeg"},

        {".jpg", "image/jpeg"},

        {".js", "application/x-javascript"},

        {".log", "text/plain"},

        {".m3u", "audio/x-mpegurl"},

        {".m4a", "audio/mp4a-latm"},

        {".m4b", "audio/mp4a-latm"},

        {".m4p", "audio/mp4a-latm"},

        {".m4u", "video/vnd.mpegurl"},

        {".m4v", "video/x-m4v"},

        {".mov", "video/quicktime"},

        {".mp2", "audio/x-mpeg"},

        {".mp3", "audio/x-mpeg"},

        {".mp4", "video/mp4"},

        {".mpc", "application/vnd.mpohun.certificate"},

        {".mpe", "video/mpeg"},

        {".mpeg", "video/mpeg"},

        {".mpg", "video/mpeg"},

        {".mpg4", "video/mp4"},

        {".mpga", "audio/mpeg"},

        {".msg", "application/vnd.ms-outlook"},

        {".ogg", "audio/ogg"},

        {".pdf", "application/pdf"},

        {".png", "image/png"},

        {".pps", "application/vnd.ms-powerpoint"},

        {".ppt", "application/vnd.ms-powerpoint"},

        {".prop", "text/plain"},

        {".rar", "application/x-rar-compressed"},

        {".rc", "text/plain"},

        {".rmvb", "audio/x-pn-realaudio"},

        {".rtf", "application/rtf"},

        {".sh", "text/plain"},

        {".tar", "application/x-tar"},

        {".tgz", "application/x-compressed"},

        {".txt", "text/plain"},

        {".wav", "audio/x-wav"},

        {".wma", "audio/x-ms-wma"},

        {".wmv", "audio/x-ms-wmv"},

        {".wps", "application/vnd.ms-works"},

        //{".xml", "text/xml"}, 

        {".xml", "text/plain"},

        {".z", "application/x-compress"},

        {".zip", "application/zip"},

        {"", "*/*"}

};