Android mime type image

Android Tutorial — Android ContentProvider MIME type

A content provider has an added responsibility to return the MIME type for a given URI.

A content provider exposes internal data as a service. Its output is like a result set from a JDBC statement. The caller should know the structure of the rows and columns returned.

A content provider allows you to determine the MIME type of the data represented by the URI.

Example

MIME types work in Android similarly to how they work in HTTP.

You get the MIME type for a given URI from a provider.

The MIME type returned is a two-part string identifying its MIME type according to the standard web MIME conventions.

A MIME type has two parts: a type and a subtype. Here are some examples of well-known MIME-type pairs:

You can see a complete list of registered types and subtypes at the Internet Assigned Numbers Authority (IANA) web site:

Type and sub types

The primary registered content types are

Each of these primary types has subtypes.

If a vendor has proprietary data formats, the subtype name begins with vnd.

For example, Microsoft Excel spreadsheets are identified by the subtype vnd.ms-excel.

Some subtypes start with x-; these are nonstandard subtypes that don’t have to be registered.

Here are a few examples:

Android MIME type

Android follows a similar convention to define MIME types.

The vnd in Android MIME types indicates that these types and subtypes are nonstandard, vendor-specific forms.

The Android MIME type for each content type has two forms: one for a specific record and one for multiple records.

For a single record, the MIME type looks like this:

For a collection of records or rows, the MIME type looks like this:

Источник

Android доступны mime-типы?

после нескольких поисков в Интернете я не мог найти место, которое могло бы сказать мне каждый существующий тип mime для разных типов носителей в приложениях android.

здесь я знаю, что существуют и работают:

на текст

на изображения

на видео

Это те, которые у меня есть и знаю, что работа, мне не хватает нескольких для видео и звука файлы. Кто-нибудь знает место, где описывается каждый тип mime android, или вы когда-нибудь использовали другой тип mime для этих разных типов носителей?

Я использую это в приложении, которое контролирует sms и mms и в типе mms управляет содержимым внутри него. Код у меня работает на любой версии выше 8.

4 ответов

Я сделал некоторые поиски в эти дни.

может быть, вы должны прочитать эти ссылки.

Я не мог найти место, которое могло бы сказать мне каждый существующий тип mime для различных типов носителей в приложениях android

в Play Store более миллиона приложений, а также другие приложения (например, предварительно установленные на устройствах, Amazon AppStore для Android). Данное устройство будет иметь некоторую комбинацию этих приложений. Данный пользователь будет иметь доступ к определенному подмножеству приложений на устройстве, если пользователь работает в Android 4.3+ ограничен профиль на планшете.

следовательно, нет никакого способа узнать, во время компиляции, какие типы MIME данное устройство Android может поддерживать для таких вещей, как ACTION_VIEW запросы активности. Сама ОС не поддерживает такие типы MIME — все они предоставляются приложениями.

здесь я знаю, что существуют и работают:

некоторые устройства могут иметь предустановленные приложения, которые поддерживают эти типы MIME. text/plain наименее вероятно, что ваш набор будет поддерживаться «из коробки».

вы можете использовать существующее отображение в Android String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension (ext.toLowerCase ());

текст/равнина text / html

аудио/видео mpeg audio / ogg

применение / json приложение / javascript применение/функции application / octet-stream

Источник

Sharing Content between Android apps

Sharing is caring, as they say, but sharing on Android means something perhaps slightly different. ‘Sharing’ is really shorthand for sending content such as text, formatted text, files, or images between apps.

So if ‘sharing’ == sending content, it makes slightly more sense that it is implemented using ACTION_SEND (or ACTION_SEND_MULTIPLE) Intents and its dozen extras.

While that approach is perfectly valid, I prefer to use ShareCompat, a set of classes in the v4 Support Library designed to make it easy to build intents for sharing content.

Sharing text

Sharing plain text is, as you might imagine, a good place to start. In fact, there’s not a whole lot to it:

ShareCompat.IntentBuilder uses a fluent API where you can chain together multiple method calls, using only the ones you need. For sharing, one of the most important parts is picking the right mime type — this is how apps filter what type of content they can receive. By using text/plain, we signify that our Intent will only contain plain text. Then, of course, setText() is how we actually add the CharSequence to the Intent to send. And while you can certainly send styled text using setText(), there’s no guarantee that the receiving app will honor that styling, so you should ensure that the text is legible with or without styling.

You’ll note we then use resolveActivity() before calling startActivity(). As mentioned in Protecting Implicit Intents with Runtime Checks, this is critical to prevent an ActivityNotFoundException when there is no Activity available to handle the mime type you have selected. While probably not as much of a concern with text/plain, it may be much more common with other types.

Note: when you use startActivity(shareIntent), that respects any default apps the user has set (i.e., if they’ve previously selected sharing all “text/plain” items to a certain app). If you’d like to instead always show a disambiguation chooser, use the intent generated from IntentBuilder.createChooserIntent() as explained in the ACTION_CHOOSER documentation.

Sharing HTML text

Some apps, most notably email clients, also support formatting with HTML. The changes, compared to plain text, are fairly minor:

The differences here are that we use of setHtmlText() in place of setText() and a mime type of text/html replacing text/plain. Here ShareCompat actually does a little bit extra: setHtmlText() also uses Html.fromHtml() to create a fallback formatted text to pass along to the receiving app if you haven’t previously called setText() yourself.

Given that many of the apps that can receive HTML text are email clients, there’s a number of helper methods to set the subject, to:, cc:, and bcc: email addresses as well — consider adding at least a subject to any share intent for best compatibility with email apps.

Of course, you’ll still want to call resolveActivity() just as before — nothing changes there.

Receiving text

While the focus so far has been on the sending side, it is helpful to know exactly what is happening on the other side (if not just to build a simple receiving app to install on your emulator for testing purposes). Receiving Activities add an intent filter to the Activity:

The action is obviously the more critical part — without that there’s nothing that would denote this as an ACTION_SEND (the action behind sharing). The mime type, same as with our sending code, is also present here. What isn’t as obvious are the two categories. From the element documentation:

Note: In order to receive implicit intents, you must include the CATEGORY_DEFAULT category in the intent filter. The methods startActivity() and startActivityForResult() treat all intents as if they declared the CATEGORY_DEFAULT category. If you do not declare it in your intent filter, no implicit intents will resolve to your activity.

So CATEGORY_DEFAULT is required for our use case. Then, CATEGORY_BROWSABLE allows web pages to natively share into apps without any extra effort required on the receiving side.

And to actually extract the information from the Intent, the useful ShareCompat.IntentReader can be used:

Similar to IntentBuilder, IntentReader is just a simple wrapper that make it easy to extract information.

Sharing files and images

While sending and receiving text is straightforward enough (create text, include it in Intent), sending files (and particularly images — the most common type by far) has an additional wrinkle: file permissions.

The simplest code you might try might look like

And that almost works — the tricky part is in getting a Uri to the File that other apps can actually read, particularly when it comes to Android 6.0 Marshmallow devices and runtime permissions (which include the now dangerous READ_EXTERNAL_STORAGE and WRITE_EXTERNAL_STORAGE permissions).

My plea: don’t use Uri.fromFile(). It forces receiving apps to have the READ_EXTERNAL_STORAGE permission, won’t work at all if you are trying to share across users, and prior to KitKat, would require your app to have WRITE_EXTERNAL_STORAGE. And really important share targets, like Gmail, won’t have the READ_EXTERNAL_STORAGE permission — so it’ll just fail.

Instead, you can use URI permissions to grant other apps access to specific Uris. While URI permissions don’t work on file:// URIs as is generated by Uri.fromFile(), they do work on Uris associated with Content Providers. Rather than implement your own just for this, you can and should use FileProvider as explained in the File Sharing Training.

Once you have it set up, our code becomes:

Using FileProvider.getUriForFile(), you’ll get a Uri actually suitable for sending to another app — they’ll be able to read it without any storage permissions — instead, you are specifically granting them read permission with FLAG_GRANT_READ_URI_PERMISSION.

Note: we don’t call setType() anywhere when building our ShareCompat (even though in the video I did set it). As explained in the setDataAndType() Javadoc, the type is automatically inferred from the data URI using getContentResolver().getType(uriToImage). Since FileProvider returns the correct mime type automatically, we don’t need to manually specify a mime type at all.

If you’re interested in learning more about avoiding the storage permission, consider watching my Forget the Storage Permission talk or at least go through the slides, which covers this topic in depth at 14:55 (slide 11).

Receiving files

Receiving files isn’t too different from text because you’re still going to use ShareCompat.IntentReader. For example, to make a Bitmap out of an incoming file, it would look like:

Of course, you’re free to do whatever you want with the InputStream — watch out for images that are so large you hit an OutOfMemoryException. All of the things you know about loading Bitmaps still apply.

The Support Library is your friend

With both ShareCompat (and its IntentBuilder and IntentReader) and FileProvider in the v4 Support Library, you’ll be able to include sharing text, HTML text, and files in your app with the best practices by default.

Источник

MIME types (IANA media types)

A media type (also known as a Multipurpose Internet Mail Extensions or MIME type) indicates the nature and format of a document, file, or assortment of bytes. MIME types are defined and standardized in IETF’s RFC 6838.

The Internet Assigned Numbers Authority (IANA) is responsible for all official MIME types, and you can find the most up-to-date and complete list at their Media Types page.

Warning: Browsers use the MIME type, not the file extension, to determine how to process a URL, so it’s important that web servers send the correct MIME type in the response’s Content-Type header. If this is not correctly configured, browsers are likely to misinterpret the contents of files, sites will not work correctly, and downloaded files may be mishandled.

Structure of a MIME type

A simplest MIME type consists of a type and a subtype. A MIME type comprises these strings concatenated with a slash ( / ). No whitespace is allowed in a MIME type:

The type represents the general category into which the data type falls, such as video or text .

The subtype identifies the exact kind of data of the specified type the MIME type represents. For example, for the MIME type text , the subtype might be plain (plain text), html (HTML source code), or calendar (for iCalendar/ .ics ) files.

Each type has its own set of possible subtypes. A MIME type always has both a type and a subtype, never just one or the other.

An optional parameter can be added to provide additional details:

For example, for any MIME type whose main type is text , you can add the optional charset parameter to specify the character set used for the characters in the data. If no charset is specified, the default is ASCII ( US-ASCII ) unless overridden by the user agent’s settings. To specify a UTF-8 text file, the MIME type text/plain;charset=UTF-8 is used.

MIME types are case-insensitive but are traditionally written in lowercase. The parameter values can be case-sensitive.

Types

There are two classes of type: discrete and multipart. Discrete types are types which represent a single file or medium, such as a single text or music file, or a single video. A multipart type is one which represents a document that’s comprised of multiple component parts, each of which may have its own individual MIME type; or, a multipart type may encapsulate multiple files being sent together in one transaction. For example, multipart MIME types are used when attaching multiple files to an email.

Discrete types

The discrete types currently registered with the IANA are:

Any kind of binary data that doesn’t fall explicitly into one of the other types; either data that will be executed or interpreted in some way or binary data that requires a specific application or category of application to use. Generic binary data (or binary data whose true type is unknown) is application/octet-stream . Other common examples include application/pdf , application/pkcs8 , and application/zip . (Registration at IANA)

Audio or music data. Examples include audio/mpeg , audio/vorbis . (Registration at IANA)

Reserved for use as a placeholder in examples showing how to use MIME types. These should never be used outside of sample code listings and documentation. example can also be used as a subtype; for instance, in an example related to working with audio on the web, the MIME type audio/example can be used to indicate that the type is a placeholder and should be replaced with an appropriate one when using the code in the real world.

Font/typeface data. Common examples include font/woff , font/ttf , and font/otf . (Registration at IANA)

Image or graphical data including both bitmap and vector still images as well as animated versions of still image formats such as animated GIF or APNG. Common examples are image/jpeg , image/png , and image/svg+xml . (Registration at IANA)

Model data for a 3D object or scene. Examples include model/3mf and model/vrml . (Registration at IANA)

Text-only data including any human-readable content, source code, or textual data such as comma-separated value (CSV) formatted data. Examples include: text/plain , text/csv , and text/html . (Registration at IANA)

Video data or files, such as MP4 movies ( video/mp4 ). (Registration at IANA)

For text documents without a specific subtype, text/plain should be used. Similarly, for binary documents without a specific or known subtype, application/octet-stream should be used.

Multipart types

Multipart types indicate a category of document broken into pieces, often with different MIME types; they can also be used — especially in email scenarios — to represent multiple, separate files which are all part of the same transaction. They represent a composite document.

With the exception of multipart/form-data , used in the POST method of HTML Forms, and multipart/byteranges , used with 206 Partial Content to send part of a document, HTTP doesn’t handle multipart documents in a special way: the message is transmitted to the browser (which will likely show a «Save As» window if it doesn’t know how to display the document).

There are two multipart types:

A message that encapsulates other messages. This can be used, for instance, to represent an email that includes a forwarded message as part of its data, or to allow sending very large messages in chunks as if it were multiple messages. Examples include message/rfc822 (for forwarded or replied-to message quoting) and message/partial to allow breaking a large message into smaller ones automatically to be reassembled by the recipient. (Registration at IANA)

Data that is comprised of multiple components which may individually have different MIME types. Examples include multipart/form-data (for data produced using the FormData API) and multipart/byteranges (defined in RFC 7233: 5.4.1 and used with HTTP’s 206 «Partial Content» response returned when the fetched data is only part of the content, such as is delivered using the Range header). (Registration at IANA)

Important MIME types for Web developers

application/octet-stream

This is the default for binary files. As it means unknown binary file, browsers usually don’t execute it, or even ask if it should be executed. They treat it as if the Content-Disposition header was set to attachment , and propose a «Save As» dialog.

text/plain

This is the default for textual files. Even if it really means «unknown textual file,» browsers assume they can display it.

Note: text/plain does not mean «any kind of textual data.» If they expect a specific kind of textual data, they will likely not consider it a match. Specifically if they download a text/plain file from a element declaring a CSS file, they will not recognize it as a valid CSS file if presented with text/plain . The CSS mime type text/css must be used.

text/css

CSS files used to style a Web page must be sent with text/css . If a server doesn’t recognize the .css suffix for CSS files, it may send them with text/plain or application/octet-stream MIME types. If so, they won’t be recognized as CSS by most browsers and will be ignored.

text/html

All HTML content should be served with this type. Alternative MIME types for XHTML (like application/xhtml+xml ) are mostly useless nowadays.

Note: Use application/xml or application/xhtml+xml if you want XML’s strict parsing rules, sections, or elements that aren’t from HTML/SVG/MathML namespaces.

text/javascript

Per the HTML specification, JavaScript files should always be served using the MIME type text/javascript . No other values are considered valid, and using any of those may result in scripts that do not load or run.

For historical reasons, the MIME Sniffing Standard (the definition of how browsers should interpret media types and figure out what to do with content that doesn’t have a valid one) allows JavaScript to be served using any MIME type that essentially matches any of the following:

• application/javascript
• application/ecmascript
• application/x-ecmascript
• application/x-javascript
• text/javascript
• text/ecmascript
• text/javascript1.0
• text/javascript1.1
• text/javascript1.2
• text/javascript1.3
• text/javascript1.4
• text/javascript1.5
• text/jscript
• text/livescript
• text/x-ecmascript
• text/x-javascript

Note: Even though any given user agent may support any or all of these, you should only use text/javascript . It’s the only MIME type guaranteed to work now and into the future.

Some content you find may have a charset parameter at the end of the text/javascript media type, to specify the character set used to represent the code’s content. This is not valid, and in most cases will result in a script not being loaded.

Image types

Files whose MIME type is image contain image data. The subtype specifies which specific image file format the data represents.

The following image types are used commonly enough to be considered safe for use on web pages:

• image/apng : Animated Portable Network Graphics (APNG)
• image/avif : AV1 Image File Format (AVIF)
• image/gif : Graphics Interchange Format (GIF)
• image/jpeg : Joint Photographic Expert Group image (JPEG)
• image/png : Portable Network Graphics (PNG)
• image/svg+xml : Scalable Vector Graphics (SVG)
• image/webp : Web Picture format (WEBP)

The Image file type and format guide provides information and recommendations about when to use the different image formats.

Audio and video types

Our media container formats guide provides a list of the file types that are commonly supported by web browsers, including information about what their special use cases may be, any drawbacks they have, and compatibility information, along with other details.

The audio codec and video codec guides list the various codecs that web browsers often support, providing compatibility details along with technical information such as how many audio channels they support, what sort of compression is used, and what bit rates and so forth they’re useful at. The codecs used by WebRTC guide expands upon this by specifically covering the codecs supported by the major web browsers, so you can choose the codecs that best cover the range of browsers you wish to support.

As for MIME types of audio or video files, they typically specify the container format (file type). The optional codecs parameter can be added to the MIME type to further specify which codecs to use and what options were used to encode the media, such as codec profile, level, or other such information.

The most commonly used MIME types used for web content are listed below. This isn’t a complete list of all the types that may be available, however. See the media container formats guide for that.

MIME type	Audio or video type
audio/wave audio/wav audio/x-wav audio/x-pn-wav	An audio file in the WAVE container format. The PCM audio codec (WAVE codec «1») is often supported, but other codecs have limited support (if any).
audio/webm	An audio file in the WebM container format. Vorbis and Opus are the codecs officially supported by the WebM specification.
video/webm	A video file, possibly with audio, in the WebM container format. VP8 and VP9 are the most common video codecs; Vorbis and Opus the most common audio codecs.
audio/ogg	An audio file in the Ogg container format. Vorbis is the most common audio codec used in such a container; however, Opus is now supported by Ogg as well.
video/ogg	A video file, possibly with audio, in the Ogg container format. Theora is the usual video codec used within it; Vorbis is the usual audio codec, although Opus is becoming more common.
application/ogg	An audio or video file using the Ogg container format. Theora is the usual video codec used within it; Vorbis is the usual audio codec.

multipart/form-data

The multipart/form-data type can be used when sending the values of a completed HTML Form from browser to server.

As a multipart document format, it consists of different parts, delimited by a boundary (a string starting with a double dash — ). Each part is its own entity with its own HTTP headers, Content-Disposition , and Content-Type for file uploading fields.

Источник