| /* |
| * Copyright (C) 2007 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.media; |
| |
| import static android.content.ContentResolver.MIME_TYPE_DEFAULT; |
| |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.mtp.MtpConstants; |
| |
| import libcore.content.type.MimeMap; |
| |
| import java.util.HashMap; |
| import java.util.Locale; |
| |
| /** |
| * MediaScanner helper class. |
| * <p> |
| * This heavily relies upon extension to MIME type mappings which are maintained |
| * in {@link MimeMap}, to ensure consistency across the OS. |
| * <p> |
| * When adding a new file type, first add the MIME type mapping to |
| * {@link MimeMap}, and then add the MTP format mapping here. |
| * |
| * @hide |
| */ |
| public class MediaFile { |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| private static final int FIRST_AUDIO_FILE_TYPE = 1; |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| private static final int LAST_AUDIO_FILE_TYPE = 10; |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| public static class MediaFileType { |
| @UnsupportedAppUsage |
| public final int fileType; |
| @UnsupportedAppUsage |
| public final String mimeType; |
| |
| MediaFileType(int fileType, String mimeType) { |
| this.fileType = fileType; |
| this.mimeType = mimeType; |
| } |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| private static final HashMap<String, MediaFileType> sFileTypeMap = new HashMap<>(); |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| private static final HashMap<String, Integer> sFileTypeToFormatMap = new HashMap<>(); |
| |
| // maps mime type to MTP format code |
| @UnsupportedAppUsage |
| private static final HashMap<String, Integer> sMimeTypeToFormatMap = new HashMap<>(); |
| // maps MTP format code to mime type |
| @UnsupportedAppUsage |
| private static final HashMap<Integer, String> sFormatToMimeTypeMap = new HashMap<>(); |
| |
| @UnsupportedAppUsage |
| public MediaFile() { |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| static void addFileType(String extension, int fileType, String mimeType) { |
| } |
| |
| private static void addFileType(int mtpFormatCode, @NonNull String mimeType) { |
| if (!sMimeTypeToFormatMap.containsKey(mimeType)) { |
| sMimeTypeToFormatMap.put(mimeType, Integer.valueOf(mtpFormatCode)); |
| } |
| if (!sFormatToMimeTypeMap.containsKey(mtpFormatCode)) { |
| sFormatToMimeTypeMap.put(mtpFormatCode, mimeType); |
| } |
| } |
| |
| static { |
| addFileType(MtpConstants.FORMAT_MP3, "audio/mpeg"); |
| addFileType(MtpConstants.FORMAT_WAV, "audio/x-wav"); |
| addFileType(MtpConstants.FORMAT_WMA, "audio/x-ms-wma"); |
| addFileType(MtpConstants.FORMAT_OGG, "audio/ogg"); |
| addFileType(MtpConstants.FORMAT_AAC, "audio/aac"); |
| addFileType(MtpConstants.FORMAT_FLAC, "audio/flac"); |
| addFileType(MtpConstants.FORMAT_AIFF, "audio/x-aiff"); |
| addFileType(MtpConstants.FORMAT_MP2, "audio/mpeg"); |
| |
| addFileType(MtpConstants.FORMAT_MPEG, "video/mpeg"); |
| addFileType(MtpConstants.FORMAT_MP4_CONTAINER, "video/mp4"); |
| addFileType(MtpConstants.FORMAT_3GP_CONTAINER, "video/3gpp"); |
| addFileType(MtpConstants.FORMAT_3GP_CONTAINER, "video/3gpp2"); |
| addFileType(MtpConstants.FORMAT_AVI, "video/avi"); |
| addFileType(MtpConstants.FORMAT_WMV, "video/x-ms-wmv"); |
| addFileType(MtpConstants.FORMAT_ASF, "video/x-ms-asf"); |
| |
| addFileType(MtpConstants.FORMAT_EXIF_JPEG, "image/jpeg"); |
| addFileType(MtpConstants.FORMAT_GIF, "image/gif"); |
| addFileType(MtpConstants.FORMAT_PNG, "image/png"); |
| addFileType(MtpConstants.FORMAT_BMP, "image/x-ms-bmp"); |
| addFileType(MtpConstants.FORMAT_HEIF, "image/heif"); |
| addFileType(MtpConstants.FORMAT_DNG, "image/x-adobe-dng"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/tiff"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-canon-cr2"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-nikon-nrw"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-sony-arw"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-panasonic-rw2"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-olympus-orf"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-pentax-pef"); |
| addFileType(MtpConstants.FORMAT_TIFF, "image/x-samsung-srw"); |
| addFileType(MtpConstants.FORMAT_TIFF_EP, "image/tiff"); |
| addFileType(MtpConstants.FORMAT_TIFF_EP, "image/x-nikon-nef"); |
| addFileType(MtpConstants.FORMAT_JP2, "image/jp2"); |
| addFileType(MtpConstants.FORMAT_JPX, "image/jpx"); |
| |
| addFileType(MtpConstants.FORMAT_M3U_PLAYLIST, "audio/x-mpegurl"); |
| addFileType(MtpConstants.FORMAT_PLS_PLAYLIST, "audio/x-scpls"); |
| addFileType(MtpConstants.FORMAT_WPL_PLAYLIST, "application/vnd.ms-wpl"); |
| addFileType(MtpConstants.FORMAT_ASX_PLAYLIST, "video/x-ms-asf"); |
| |
| addFileType(MtpConstants.FORMAT_TEXT, "text/plain"); |
| addFileType(MtpConstants.FORMAT_HTML, "text/html"); |
| addFileType(MtpConstants.FORMAT_XML_DOCUMENT, "text/xml"); |
| |
| addFileType(MtpConstants.FORMAT_MS_WORD_DOCUMENT, |
| "application/msword"); |
| addFileType(MtpConstants.FORMAT_MS_WORD_DOCUMENT, |
| "application/vnd.openxmlformats-officedocument.wordprocessingml.document"); |
| addFileType(MtpConstants.FORMAT_MS_EXCEL_SPREADSHEET, |
| "application/vnd.ms-excel"); |
| addFileType(MtpConstants.FORMAT_MS_EXCEL_SPREADSHEET, |
| "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"); |
| addFileType(MtpConstants.FORMAT_MS_POWERPOINT_PRESENTATION, |
| "application/vnd.ms-powerpoint"); |
| addFileType(MtpConstants.FORMAT_MS_POWERPOINT_PRESENTATION, |
| "application/vnd.openxmlformats-officedocument.presentationml.presentation"); |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static boolean isAudioFileType(int fileType) { |
| return false; |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static boolean isVideoFileType(int fileType) { |
| return false; |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static boolean isImageFileType(int fileType) { |
| return false; |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static boolean isPlayListFileType(int fileType) { |
| return false; |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static boolean isDrmFileType(int fileType) { |
| return false; |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static MediaFileType getFileType(String path) { |
| return null; |
| } |
| |
| /** |
| * Check whether the mime type is document or not. |
| * @param mimeType the mime type to check |
| * @return true, if the mimeType is matched. Otherwise, false. |
| */ |
| public static boolean isDocumentMimeType(@Nullable String mimeType) { |
| if (mimeType == null) { |
| return false; |
| } |
| |
| final String normalizedMimeType = normalizeMimeType(mimeType); |
| if (normalizedMimeType.startsWith("text/")) { |
| return true; |
| } |
| |
| switch (normalizedMimeType.toLowerCase(Locale.ROOT)) { |
| case "application/epub+zip": |
| case "application/msword": |
| case "application/pdf": |
| case "application/rtf": |
| case "application/vnd.ms-excel": |
| case "application/vnd.ms-excel.addin.macroenabled.12": |
| case "application/vnd.ms-excel.sheet.binary.macroenabled.12": |
| case "application/vnd.ms-excel.sheet.macroenabled.12": |
| case "application/vnd.ms-excel.template.macroenabled.12": |
| case "application/vnd.ms-powerpoint": |
| case "application/vnd.ms-powerpoint.addin.macroenabled.12": |
| case "application/vnd.ms-powerpoint.presentation.macroenabled.12": |
| case "application/vnd.ms-powerpoint.slideshow.macroenabled.12": |
| case "application/vnd.ms-powerpoint.template.macroenabled.12": |
| case "application/vnd.ms-word.document.macroenabled.12": |
| case "application/vnd.ms-word.template.macroenabled.12": |
| case "application/vnd.oasis.opendocument.chart": |
| case "application/vnd.oasis.opendocument.database": |
| case "application/vnd.oasis.opendocument.formula": |
| case "application/vnd.oasis.opendocument.graphics": |
| case "application/vnd.oasis.opendocument.graphics-template": |
| case "application/vnd.oasis.opendocument.presentation": |
| case "application/vnd.oasis.opendocument.presentation-template": |
| case "application/vnd.oasis.opendocument.spreadsheet": |
| case "application/vnd.oasis.opendocument.spreadsheet-template": |
| case "application/vnd.oasis.opendocument.text": |
| case "application/vnd.oasis.opendocument.text-master": |
| case "application/vnd.oasis.opendocument.text-template": |
| case "application/vnd.oasis.opendocument.text-web": |
| case "application/vnd.openxmlformats-officedocument.presentationml.presentation": |
| case "application/vnd.openxmlformats-officedocument.presentationml.slideshow": |
| case "application/vnd.openxmlformats-officedocument.presentationml.template": |
| case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": |
| case "application/vnd.openxmlformats-officedocument.spreadsheetml.template": |
| case "application/vnd.openxmlformats-officedocument.wordprocessingml.document": |
| case "application/vnd.openxmlformats-officedocument.wordprocessingml.template": |
| case "application/vnd.stardivision.calc": |
| case "application/vnd.stardivision.chart": |
| case "application/vnd.stardivision.draw": |
| case "application/vnd.stardivision.impress": |
| case "application/vnd.stardivision.impress-packed": |
| case "application/vnd.stardivision.mail": |
| case "application/vnd.stardivision.math": |
| case "application/vnd.stardivision.writer": |
| case "application/vnd.stardivision.writer-global": |
| case "application/vnd.sun.xml.calc": |
| case "application/vnd.sun.xml.calc.template": |
| case "application/vnd.sun.xml.draw": |
| case "application/vnd.sun.xml.draw.template": |
| case "application/vnd.sun.xml.impress": |
| case "application/vnd.sun.xml.impress.template": |
| case "application/vnd.sun.xml.math": |
| case "application/vnd.sun.xml.writer": |
| case "application/vnd.sun.xml.writer.global": |
| case "application/vnd.sun.xml.writer.template": |
| case "application/x-mspublisher": |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| public static boolean isExifMimeType(@Nullable String mimeType) { |
| // For simplicity, assume that all image files might have EXIF data |
| return isImageMimeType(mimeType); |
| } |
| |
| public static boolean isAudioMimeType(@Nullable String mimeType) { |
| return normalizeMimeType(mimeType).startsWith("audio/"); |
| } |
| |
| public static boolean isVideoMimeType(@Nullable String mimeType) { |
| return normalizeMimeType(mimeType).startsWith("video/"); |
| } |
| |
| public static boolean isImageMimeType(@Nullable String mimeType) { |
| return normalizeMimeType(mimeType).startsWith("image/"); |
| } |
| |
| public static boolean isPlayListMimeType(@Nullable String mimeType) { |
| switch (normalizeMimeType(mimeType)) { |
| case "application/vnd.ms-wpl": |
| case "audio/x-mpegurl": |
| case "audio/mpegurl": |
| case "application/x-mpegurl": |
| case "application/vnd.apple.mpegurl": |
| case "audio/x-scpls": |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| public static boolean isDrmMimeType(@Nullable String mimeType) { |
| return normalizeMimeType(mimeType).equals("application/x-android-drm-fl"); |
| } |
| |
| // generates a title based on file name |
| @UnsupportedAppUsage |
| public static @NonNull String getFileTitle(@NonNull String path) { |
| // extract file name after last slash |
| int lastSlash = path.lastIndexOf('/'); |
| if (lastSlash >= 0) { |
| lastSlash++; |
| if (lastSlash < path.length()) { |
| path = path.substring(lastSlash); |
| } |
| } |
| // truncate the file extension (if any) |
| int lastDot = path.lastIndexOf('.'); |
| if (lastDot > 0) { |
| path = path.substring(0, lastDot); |
| } |
| return path; |
| } |
| |
| public static @Nullable String getFileExtension(@Nullable String path) { |
| if (path == null) { |
| return null; |
| } |
| int lastDot = path.lastIndexOf('.'); |
| if (lastDot >= 0) { |
| return path.substring(lastDot + 1); |
| } else { |
| return null; |
| } |
| } |
| |
| /** @deprecated file types no longer exist */ |
| @Deprecated |
| @UnsupportedAppUsage |
| public static int getFileTypeForMimeType(String mimeType) { |
| return 0; |
| } |
| |
| /** |
| * Find the best MIME type for the given item. Prefers mappings from file |
| * extensions, since they're more accurate than format codes. |
| */ |
| public static @NonNull String getMimeType(@Nullable String path, int formatCode) { |
| // First look for extension mapping |
| String mimeType = getMimeTypeForFile(path); |
| if (!MIME_TYPE_DEFAULT.equals(mimeType)) { |
| return mimeType; |
| } |
| |
| // Otherwise look for format mapping |
| return getMimeTypeForFormatCode(formatCode); |
| } |
| |
| @UnsupportedAppUsage |
| public static @NonNull String getMimeTypeForFile(@Nullable String path) { |
| String ext = getFileExtension(path); |
| final String mimeType = MimeMap.getDefault().guessMimeTypeFromExtension(ext); |
| return (mimeType != null) ? mimeType : MIME_TYPE_DEFAULT; |
| } |
| |
| public static @NonNull String getMimeTypeForFormatCode(int formatCode) { |
| final String mimeType = sFormatToMimeTypeMap.get(formatCode); |
| return (mimeType != null) ? mimeType : MIME_TYPE_DEFAULT; |
| } |
| |
| /** |
| * Find the best MTP format code mapping for the given item. Prefers |
| * mappings from MIME types, since they're more accurate than file |
| * extensions. |
| */ |
| public static int getFormatCode(@Nullable String path, @Nullable String mimeType) { |
| // First look for MIME type mapping |
| int formatCode = getFormatCodeForMimeType(mimeType); |
| if (formatCode != MtpConstants.FORMAT_UNDEFINED) { |
| return formatCode; |
| } |
| |
| // Otherwise look for extension mapping |
| return getFormatCodeForFile(path); |
| } |
| |
| public static int getFormatCodeForFile(@Nullable String path) { |
| return getFormatCodeForMimeType(getMimeTypeForFile(path)); |
| } |
| |
| public static int getFormatCodeForMimeType(@Nullable String mimeType) { |
| if (mimeType == null) { |
| return MtpConstants.FORMAT_UNDEFINED; |
| } |
| |
| // First look for direct mapping |
| Integer value = sMimeTypeToFormatMap.get(mimeType); |
| if (value != null) { |
| return value.intValue(); |
| } |
| |
| // Otherwise look for indirect mapping |
| mimeType = normalizeMimeType(mimeType); |
| value = sMimeTypeToFormatMap.get(mimeType); |
| if (value != null) { |
| return value.intValue(); |
| } else if (mimeType.startsWith("audio/")) { |
| return MtpConstants.FORMAT_UNDEFINED_AUDIO; |
| } else if (mimeType.startsWith("video/")) { |
| return MtpConstants.FORMAT_UNDEFINED_VIDEO; |
| } else if (mimeType.startsWith("image/")) { |
| return MtpConstants.FORMAT_DEFINED; |
| } else { |
| return MtpConstants.FORMAT_UNDEFINED; |
| } |
| } |
| |
| /** |
| * Normalize the given MIME type by bouncing through a default file |
| * extension, if defined. This handles cases like "application/x-flac" to |
| * ".flac" to "audio/flac". |
| */ |
| private static @NonNull String normalizeMimeType(@Nullable String mimeType) { |
| MimeMap mimeMap = MimeMap.getDefault(); |
| final String extension = mimeMap.guessExtensionFromMimeType(mimeType); |
| if (extension != null) { |
| final String extensionMimeType = mimeMap.guessMimeTypeFromExtension(extension); |
| if (extensionMimeType != null) { |
| return extensionMimeType; |
| } |
| } |
| return (mimeType != null) ? mimeType : MIME_TYPE_DEFAULT; |
| } |
| } |
