Java Code Examples for android.webkit.MimeTypeMap#getFileExtensionFromUrl()

private String getMimeTypeFromUri(Uri contentUri) {
  String type = getReactApplicationContext().getContentResolver().getType(contentUri);

  if (type == null) {
    String ext = MimeTypeMap.getFileExtensionFromUrl(contentUri.getPath());
    if (ext != null) {
      type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext);
    }
  }

  if (type == null) {
    type = "";
  }

  return type;
}
 

public String getMimeType(String url) {
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        switch (extension) {
            case "js":
                return "text/javascript";
            case "woff":
                return "application/font-woff";
            case "woff2":
                return "application/font-woff2";
            case "ttf":
                return "application/x-font-ttf";
            case "eot":
                return "application/vnd.ms-fontobject";
            case "svg":
                return "image/svg+xml";
            default:
                return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
        }
    }
    return null;
}
 

/**
 * Returns the MIME Type of the file by looking at file name extension in
 * the URL.
 *
 * @param url
 * @return
 */
private static String getMimeType(String url) {
    String mimeType = null;
    System.out.println("Url: " + url);
    url = url.replaceAll(" ", "");
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

    if (mimeType == null) {
        mimeType = "application/pdf";
        System.out.println("Mime Type (default): " + mimeType);
    }

    return mimeType;
}
 

private String getMimeType(String url) {
    String type = null;
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return type;
}
 

public static boolean isArchive(@Nullable String name) {
    if (StringUtils.isBlank(name)) return false;
    name = name.toLowerCase();
    for (String value : ARCHIVE_EXTENSIONS) {
        String extension = MimeTypeMap.getFileExtensionFromUrl(name);
        if ((extension != null && value.replace(".", "").equals(extension))
                || name.endsWith(value))
            return true;
    }

    return false;
}
 

public static String getMimeTypeForFile(String uri) {
    String type = null;
    String extension = MimeTypeMap.getFileExtensionFromUrl(uri);
    if (extension != null) {
        MimeTypeMap mime = MimeTypeMap.getSingleton();
        type = mime.getMimeTypeFromExtension(extension);
    }
    return type;
}
 

public static String getMimeType(String url) {
    String type = "";
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (!TextUtils.isEmpty(extension)) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    } else {
        String reCheckExtension = MimeTypeMap.getFileExtensionFromUrl(url.replaceAll("\\s+", ""));
        if (!TextUtils.isEmpty(reCheckExtension)) {
            type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(reCheckExtension);
        }
    }
    return type;
}
 

public static String getMimeType(String url) {
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return null;
}
 

public StreamSource(SmbFile file,long l) throws SmbException {

        fp = 0;
        len = l;
        mime = MimeTypeMap.getFileExtensionFromUrl(file.getName());
        name = file.getName();
        this.file = file;
        bufferSize = 1024*60;
    }
 

@Override
public String mimeType() {
    String type = "application/octet-stream";
    String name = file.getName();
    // 判断文件是否有扩展名，有则根据扩展名拿到type。
    if (MimeTypeMap.getSingleton().hasExtension(name)) {
        String extension = MimeTypeMap.getFileExtensionFromUrl(name);
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return type;
}
 

public static long downloadFile(Context context, String url, String mimeType) {
    try {
        String[] fnm = url.split("/");
        String fileName = fnm[fnm.length - 1];
        fileName = getFileName(fileName);
        String host = fnm[2];
        String extension = MimeTypeMap.getFileExtensionFromUrl(url);
        if(extension.equals(""))
            extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
        String fileNameWithExtension = fileName + "." + extension;

        DownloadManager dm = (DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
        Uri uri = Uri.parse(url);
        DownloadManager.Request request = new DownloadManager.Request(uri);
        request.setTitle(fileNameWithExtension);
        request.setMimeType(mimeType);
        request.setDescription(host);
        request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileNameWithExtension);
        File downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);

        if (!downloadsDir.exists()) {
            //noinspection ResultOfMethodCallIgnored
            downloadsDir.mkdirs();
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
        } else {
            //noinspection deprecation
            request.setShowRunningNotification(true);
        }
        request.setVisibleInDownloadsUi(true);
        long downloadId = dm.enqueue(request);

        Toast.makeText(context, context.getString(R.string.message_download_started), Toast.LENGTH_SHORT).show();

        return downloadId;
    } catch (SecurityException e) {
        throw new SecurityException("No permission allowed: android.permission.WRITE_EXTERNAL_STORAGE");
    }
}
 

/**
 * Obtain mime type from URL
 * @param url {@link String}
 * @return {@link String} mime type
 */
private String getMimeType(String url) {
    String type = null;
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return type;
}
 

static String getSupposablyMime(String url) {
    MimeTypeMap mimes = MimeTypeMap.getSingleton();
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    return TextUtils.isEmpty(extension) ? null : mimes.getMimeTypeFromExtension(extension);
}
 

static String getSupposablyMime(String url) {
    MimeTypeMap mimes = MimeTypeMap.getSingleton();
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    return TextUtils.isEmpty(extension) ? null : mimes.getMimeTypeFromExtension(extension);
}
 

public static String getFileType(String filePath) {
    String ext = MimeTypeMap.getFileExtensionFromUrl(filePath);
    return MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext);
}
 

/**
 * Detect MimeType of given file
 * Android/Java's own MimeType map is very very small and detection barely works at all
 * Hence use custom map for some file extensions
 */
public String getMimeType(final Uri uri) {
    String mimeType = null;
    if (ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) {
        ContentResolver cr = _context.getContentResolver();
        mimeType = cr.getType(uri);
    } else {
        String ext = MimeTypeMap.getFileExtensionFromUrl(uri.toString());
        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext.toLowerCase());

        // Try to guess if the recommended methods fail
        if (TextUtils.isEmpty(mimeType)) {
            switch (ext) {
                case "md":
                case "markdown":
                case "mkd":
                case "mdown":
                case "mkdn":
                case "mdwn":
                case "rmd":
                    mimeType = "text/markdown";
                    break;
                case "yaml":
                case "yml":
                    mimeType = "text/yaml";
                    break;
                case "json":
                    mimeType = "text/json";
                    break;
                case "txt":
                    mimeType = "text/plain";
                    break;
            }
        }
    }

    if (TextUtils.isEmpty(mimeType)) {
        mimeType = "*/*";
    }
    return mimeType;
}
 

public static String getExtension(@Nullable String name) {
    if (StringUtils.isBlank(name)) return null;
    return MimeTypeMap.getFileExtensionFromUrl(name);
}
 

private boolean isVideoFileUri(String uri) {
	String extension = MimeTypeMap.getFileExtensionFromUrl(uri);
	String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
	return mimeType != null && mimeType.startsWith("video/");
}
 

public void initData() {
        imageLoader = ImageLoader.getInstance();
        imageUrls = new ArrayList<String>();

        Intent intent = getIntent();
        if (intent != null) {
            Bundle bundle = intent.getExtras();
            if (bundle != null) {
                imageUrls = bundle.getStringArrayList(Extra.IMAGES);
                imagePosition = bundle.getInt(Extra.IMAGE_POSITION, 0);
                imageMode = bundle.getInt(Extra.IMAGE_MODE, 0);
                Log.i("The snowdream bundle path of the image is: " + imageUri);
            }

            Uri uri = (Uri) intent.getData();
            if (uri != null) {
                imageUri = uri.getPath();
                fileName = uri.getLastPathSegment();
                getSupportActionBar().setSubtitle(fileName);
                Log.i("The path of the image is: " + imageUri);

                File file = new File(imageUri);

                imageUri = "file://" + imageUri;
                File dir = file.getParentFile();
                if (dir != null) {
                    FileFilter fileFilter = new FileFilter() {
                        @Override
                        public boolean accept(File f) {
                            if (f != null) {
                                String extension = MimeTypeMap.getFileExtensionFromUrl(Uri.encode(f.getAbsolutePath()));
                                if (!TextUtils.isEmpty(extension)) {
                                    String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
                                    if (!TextUtils.isEmpty(mimeType) && mimeType.contains("image")) {
                                        return true;
                                    }
                                }
                            }
                        return false;
                    }
                } ;

                File[] files = dir.listFiles(fileFilter);

                if (files != null && files.length > 0) {
                    int size = files.length;

                    for (int i = 0; i < size; i++) {
                        imageUrls.add("file://" + files[i].getAbsolutePath());
                    }
                    imagePosition = imageUrls.indexOf(imageUri);
                    imageMode = 1;
                    Log.i("Image Position:" + imagePosition);
                }

            } else {
                imageUrls.add("file://" + imageUri);
                imagePosition = 0;
                imageMode = 0;
            }
        }
    }

    else

    {
        Log.w("The intent is null!");
    }

}
 

/**
 * Get he extension by url.
 *
 * @param url url.
 *
 * @return extension name.
 */
public static String getUrlExtension(String url) {
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    return TextUtils.isEmpty(extension) ? "" : extension;
}