diff options
Diffstat (limited to 'mime')
| -rw-r--r-- | mime/Android.bp | 115 | ||||
| -rw-r--r-- | mime/TEST_MAPPING | 7 | ||||
| -rw-r--r-- | mime/jarjar-rules.txt | 1 | ||||
| -rw-r--r-- | mime/java-res/android.mime.types | 146 | ||||
| -rw-r--r-- | mime/java-res/vendor.mime.types | 41 | ||||
| -rw-r--r-- | mime/java/android/content/type/DefaultMimeMapFactory.java | 111 |
6 files changed, 421 insertions, 0 deletions
diff --git a/mime/Android.bp b/mime/Android.bp new file mode 100644 index 000000000000..51290f6b1176 --- /dev/null +++ b/mime/Android.bp @@ -0,0 +1,115 @@ +// Copyright (C) 2019 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + + +java_defaults { + name: "mimemap-defaults", + srcs: [ + "java/android/content/type/DefaultMimeMapFactory.java", + ], + sdk_version: "core_platform", +} + +java_library { + name: "mimemap", + defaults: ["mimemap-defaults"], + static_libs: ["mimemap-res.jar"], + visibility: [ + "//frameworks/base:__subpackages__", + ], +} + +java_library { + name: "mimemap-testing", + defaults: ["mimemap-defaults"], + static_libs: ["mimemap-testing-res.jar"], + jarjar_rules: "jarjar-rules.txt", + visibility: [ + "//cts/tests/tests/mimemap:__subpackages__", + "//frameworks/base:__subpackages__", + ], +} + +// The mimemap-res.jar and mimemap-testing-res.jar genrules produce a .jar that +// has the resource file in a subdirectory res/ and testres/, respectively. +// Those paths need to They need to be in different paths because one of them +// ends up on a bootclasspath jar whereas the other one ends up in a test jar. +// Bootclasspath resources hide test or application resources under the same +// path because ClassLoader.getResource(String) consults the parent ClassLoader +// first. +// +// Further notes: +// - the "cp" command will flatten any directory paths that occur in $(in), +// but here they happen to already be in the root directory. If we needed +// to preserve sub paths then we might want to zip the files first and then +// unzip them below the new parent directory. +// - the path names "res/" and "testres/" and duplicated in .java source files +// (DefaultMimeMapFactory.java and MimeMapTest.java, as of October 2019). +java_genrule { + name: "mimemap-res.jar", + tools: [ + "soong_zip", + ], + srcs: [":mime.types"], + out: ["mimemap-res.jar"], + cmd: "mkdir $(genDir)/res/ && cp $(in) $(genDir)/res/ && $(location soong_zip) -C $(genDir) -o $(out) -D $(genDir)/res/", +} + +// The same as mimemap-res.jar except that the resources are placed in a different directory. +// They get bundled with CTS so that CTS can compare a device's MimeMap implementation vs. +// the stock Android one from when CTS was built. +java_genrule { + name: "mimemap-testing-res.jar", + tools: [ + "soong_zip", + ], + srcs: [":mime.types"], + out: ["mimemap-testing-res.jar"], + cmd: "mkdir $(genDir)/testres/ && cp $(in) $(genDir)/testres/ && $(location soong_zip) -C $(genDir) -o $(out) -D $(genDir)/testres/", +} + +// Combination of all *mime.types resources. +filegroup { + name: "mime.types", + visibility: [ + "//visibility:private", + ], + srcs: [ + ":debian.mime.types", + ":android.mime.types", + ":vendor.mime.types", + ], +} + +filegroup { + name: "android.mime.types", + visibility: [ + "//visibility:private", + ], + path: "java-res/", + srcs: [ + "java-res/android.mime.types", + ], +} + +filegroup { + name: "vendor.mime.types", + visibility: [ + "//visibility:private", + ], + path: "java-res/", + srcs: [ + "java-res/vendor.mime.types", + ], +} diff --git a/mime/TEST_MAPPING b/mime/TEST_MAPPING new file mode 100644 index 000000000000..8daab754ea8a --- /dev/null +++ b/mime/TEST_MAPPING @@ -0,0 +1,7 @@ +{ + "presubmit": [ + { + "name": "CtsMimeMapTestCases" + } + ] +} diff --git a/mime/jarjar-rules.txt b/mime/jarjar-rules.txt new file mode 100644 index 000000000000..145d1dbf3d11 --- /dev/null +++ b/mime/jarjar-rules.txt @@ -0,0 +1 @@ +rule android.content.type.DefaultMimeMapFactory android.content.type.cts.StockAndroidMimeMapFactory
\ No newline at end of file diff --git a/mime/java-res/android.mime.types b/mime/java-res/android.mime.types new file mode 100644 index 000000000000..7a5299ff1b69 --- /dev/null +++ b/mime/java-res/android.mime.types @@ -0,0 +1,146 @@ + +############################################################################### +# +# Android-specific MIME type <-> extension mappings +# +# Each line below defines a mapping from one MIME type to the first of the +# listed extensions, and from listed extension back to the MIME type. +# A mapping overrides any previous mapping _from_ that same MIME type or +# extension (put() semantics), unless that MIME type / extension is prefixed with '?' +# (putIfAbsent() semantics). +# +# +############################################################################### +# +# EXAMPLES +# +# A line of the form: +# +# ?mime ext1 ?ext2 ext3 +# +# affects the current mappings along the lines of the following pseudo code: +# +# mimeToExt.putIfAbsent("mime", "ext1"); +# extToMime.put("ext1", "mime"); +# extToMime.putIfAbsent("ext2", "mime"); +# extToMime.put("ext3", "mime"); +# +# The line: +# +# ?text/plain txt +# +# leaves any earlier mapping for "text/plain" untouched, or maps that MIME type +# to the file extension ".txt" if there is no earlier mapping. The line also +# sets the mapping from file extension ".txt" to be the MIME type "text/plain", +# regardless of whether a previous mapping existed. +# +############################################################################### + + +# File extensions that Android wants to override to point to the given MIME type. +# +# After processing a line of the form: +# ?<mimeType> <extension1> <extension2> +# If <mimeType> was not already mapped to an extension then it will be +# mapped to <extension1>. +# <extension1> and <extension2> are mapped (or remapped) to <mimeType>. + +?application/epub+zip epub +?application/pkix-cert cer +?application/rss+xml rss +?application/vnd.android.ota ota +?application/vnd.apple.mpegurl m3u8 +?application/vnd.ms-pki.stl stl +?application/vnd.ms-powerpoint pot +?application/vnd.ms-wpl wpl +?application/vnd.stardivision.impress sdp +?application/vnd.stardivision.writer vor +?application/vnd.youtube.yt yt +?application/x-android-drm-fl fl +?application/x-flac flac +?application/x-font pcf +?application/x-mpegurl m3u m3u8 +?application/x-pem-file pem +?application/x-pkcs12 p12 pfx +?application/x-webarchive webarchive +?application/x-webarchive-xml webarchivexml +?application/x-x509-server-cert crt +?application/x-x509-user-cert crt + +?audio/3gpp 3gpp +?audio/aac-adts aac +?audio/imelody imy +?audio/midi rtttl xmf +?audio/mobile-xmf mxmf +?audio/mp4 m4a +?audio/mpegurl m3u +?audio/sp-midi smf +?audio/x-matroska mka +?audio/x-pn-realaudio ra + +?image/bmp bmp +?image/heic heic +?image/heic-sequence heics +?image/heif heif hif +?image/heif-sequence heifs +?image/ico cur +?image/webp webp +?image/x-adobe-dng dng +?image/x-fuji-raf raf +?image/x-icon ico +?image/x-nikon-nrw nrw +?image/x-panasonic-rw2 rw2 +?image/x-pentax-pef pef +?image/x-samsung-srw srw +?image/x-sony-arw arw + +?text/comma-separated-values csv +?text/plain diff po +?text/rtf rtf +?text/text phps +?text/xml xml +?text/x-vcard vcf + +?video/3gpp2 3gpp2 3g2 +?video/3gpp 3gpp +?video/avi avi +?video/m4v m4v +?video/mp2p mpeg +?video/mp2t m2ts mts +?video/mp2ts ts +?video/vnd.youtube.yt yt +?video/x-webex wrf + +# Optional additions that should not override any previous mapping. + +?application/x-wifi-config ?xml + +# Special cases where Android has a strong opinion about mappings, so we +# define them very last and make them override in both directions (no "?"). +# +# Lines here are of the form: +# <mimeType> <extension1> <extension2> ... +# +# After processing each line, +# <mimeType> is mapped to <extension1> +# <extension1>, <extension2>, ... are all mapped to <mimeType> +# This overrides any mappings for this <mimeType> / for these extensions +# that may have been defined earlier. + +application/pgp-signature pgp +application/x-x509-ca-cert crt +audio/aac aac +audio/basic snd +audio/flac flac +audio/midi rtx +audio/mpeg mp3 m4a m4r +audio/x-mpegurl m3u m3u8 +image/jpeg jpg +image/x-ms-bmp bmp +text/plain txt +text/x-c++hdr hpp +text/x-c++src cpp +video/3gpp 3gpp +video/mpeg mpeg +video/quicktime mov +video/x-matroska mkv diff --git a/mime/java-res/vendor.mime.types b/mime/java-res/vendor.mime.types new file mode 100644 index 000000000000..afb8f9e4ef39 --- /dev/null +++ b/mime/java-res/vendor.mime.types @@ -0,0 +1,41 @@ +############################################################################### +# +# Vendor-specific MIME type <-> extension mappings +# +# Each line below defines a mapping from one MIME type to the first of the +# listed extensions, and from listed extension back to the MIME type. +# +# This file can _add_ additional mappings that are not in the default set, +# but it it cannot _modify_ (replace or remove) any platform default mapping +# (defined in files mime.types and android.mime.types). +# +############################################################################### +# +# EXAMPLES +# +# A line of the form (without the leading '#''): +# +# mime ext1 ext2 ext3 +# +# affects the current mappings along the lines of the following pseudo code: +# +# mimeToExt.putIfAbsent("mime", "ext1"); +# extToMime.putIfAbsent("ext1", "mime"); +# extToMime.putIfAbsent("ext2", "mime"); +# extToMime.putIfAbsent("ext3", "mime"); +# +# Optionally, MIME types or extensions may be prefixed by a single '?', which +# will be ignored. I.e., the following example lines all have the same semantics: +# +# mime ext1 ext2 ext3 +# ?mime ext1 ext2 ext3 +# mime ?ext1 ext2 ?ext3 +# ?mime ?ext1 ?ext2 ?ext3 +# +# By default, this file contains no mappings (which means that the platform +# default mapping is used unmodified). +# +############################################################################### +# +# Add your custom mappings below this line (with no "#" at the start of the line): + diff --git a/mime/java/android/content/type/DefaultMimeMapFactory.java b/mime/java/android/content/type/DefaultMimeMapFactory.java new file mode 100644 index 000000000000..13039a4ab1e2 --- /dev/null +++ b/mime/java/android/content/type/DefaultMimeMapFactory.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.content.type; + +import libcore.net.MimeMap; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.function.Function; +import java.util.regex.Pattern; + +/** + * Creates the framework default {@link MimeMap}, a bidirectional mapping + * between MIME types and file extensions. + * + * This default mapping is loaded from data files that start with some mappings + * recognized by IANA plus some custom extensions and overrides. + * + * @hide + */ +public class DefaultMimeMapFactory { + + private DefaultMimeMapFactory() { + } + + /** + * Creates and returns a new {@link MimeMap} instance that implements. + * Android's default mapping between MIME types and extensions. + */ + public static MimeMap create() { + Class c = DefaultMimeMapFactory.class; + // The resources are placed into the res/ path by the "mimemap-res.jar" genrule. + return create(resourceName -> c.getResourceAsStream("/res/" + resourceName)); + } + + private static final Pattern SPLIT_PATTERN = Pattern.compile("\\s+"); + + /** + * Creates a {@link MimeMap} instance whose resources are loaded from the + * InputStreams looked up in {@code resourceSupplier}. + * + * @hide + */ + public static MimeMap create(Function<String, InputStream> resourceSupplier) { + MimeMap.Builder builder = MimeMap.builder(); + parseTypes(builder, true, resourceSupplier, "mime.types"); + parseTypes(builder, true, resourceSupplier, "android.mime.types"); + parseTypes(builder, false, resourceSupplier, "vendor.mime.types"); + return builder.build(); + } + + private static void parseTypes(MimeMap.Builder builder, boolean allowOverwrite, + Function<String, InputStream> resourceSupplier, String resourceName) { + try (InputStream inputStream = Objects.requireNonNull(resourceSupplier.apply(resourceName)); + BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) { + String line; + while ((line = reader.readLine()) != null) { + int commentPos = line.indexOf('#'); + if (commentPos >= 0) { + line = line.substring(0, commentPos); + } + line = line.trim(); + if (line.isEmpty()) { + continue; + } + List<String> specs = Arrays.asList(SPLIT_PATTERN.split(line)); + if (!allowOverwrite) { + // Pretend that the mimeType and each file extension listed in the line + // carries a "?" prefix, which means that it can add new mappings but + // not modify existing mappings (putIfAbsent() semantics). + specs = ensurePrefix("?", specs); + } + builder.put(specs.get(0), specs.subList(1, specs.size())); + } + } catch (IOException | RuntimeException e) { + throw new RuntimeException("Failed to parse " + resourceName, e); + } + } + + private static List<String> ensurePrefix(String prefix, List<String> strings) { + List<String> result = new ArrayList<>(strings.size()); + for (String s : strings) { + if (!s.startsWith(prefix)) { + s = prefix + s; + } + result.add(s); + } + return result; + } + +} |