import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
protected Collection<MimeType> getMimeTypesFileName(String name) {
  int s = name.lastIndexOf('/');
  if (s >= 0) {
    name = name.substring(s + 1);
  }

  MimeType type = TYPES.get(name);
  if (type != null) {
    return Collections.singletonList(type);
  }

  int d = name.lastIndexOf('.');
  if (0 < d) {
    type = TYPES.get(name.substring(d + 1));
    if (type != null) {
      return Collections.singletonList(type);
    }
  }

  return Collections.emptyList();
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Get specificity of mime types with generic types forced to low values
 *
 * <p>"application/octet-stream" is forced to -1. "text/plain" is forced to 0. All other mime
 * types return the specificity reported by mimeType itself.
 *
 * @param mimeType The mimeType to get the corrected specificity for.
 * @return The corrected specificity.
 */
private int getCorrectedMimeSpecificity(MimeType mimeType) {
  // Although the documentation of MimeType's getSpecificity claims that for
  // example "application/octet-stream" always has a specificity of 0, it
  // effectively returns 1 for us. This causes problems when trying to get
  // the correct mime type via sorting. For example in
  // [application/octet-stream, image/x-icon] both mime types come with
  // specificity 1 for us. Hence, getMimeType below may end up using
  // application/octet-stream instead of the more specific image/x-icon.
  // Therefore, we have to force the specificity of generic types below the
  // default of 1.
  //
  final String mimeTypeStr = mimeType.toString();
  if (mimeTypeStr.equals("application/octet-stream")) {
    return -1;
  }
  if (mimeTypeStr.equals("text/plain")) {
    return 0;
  }
  return mimeType.getSpecificity();
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private MimeType getMimeType(Set<MimeType> mimeTypes, String path) {
  try {
    mimeTypes.addAll(mimeUtil.getMimeTypes(path));
  } catch (MimeException e) {
    log.warn("Unable to determine MIME type from path", e);
  }

  if (isUnknownType(mimeTypes)) {
    return MimeUtil2.UNKNOWN_MIME_TYPE;
  }

  final List<MimeType> types = new ArrayList<>(mimeTypes);
  Collections.sort(
      types,
      new Comparator<MimeType>() {
        @Override
        public int compare(MimeType a, MimeType b) {
          return getCorrectedMimeSpecificity(b) - getCorrectedMimeSpecificity(a);
        }
      });
  return types.get(0);
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Get the mime types that may be contained in the data array.
 *
 * @param data. The byte array that contains data we want to detect mime types from.
 * @return the mime types.
 * @throws MimeException if for instance we try to match beyond the end of the data.
 */
public Collection<MimeType> getMimeTypesByteArray(final byte[] data)
		throws UnsupportedOperationException {
	Collection<MimeType> mimeTypes = new LinkedHashSet<MimeType>();
	int len = mMagicMimeEntries.size();
	try {
		for (int i = 0; i < len; i++) {
			MagicMimeEntry me = (MagicMimeEntry) mMagicMimeEntries.get(i);
			MagicMimeEntry matchingMagicMimeEntry = me.getMatch(data);
			if (matchingMagicMimeEntry != null) {
				mimeTypes.add(matchingMagicMimeEntry.getMimeType());
			}
		}
	} catch (Exception e) {
		AppState.log(TAG, e.getMessage());
	}
	return mimeTypes;
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Get the mime types of the data in the specified {@link InputStream}.
 * Therefore, the <code>InputStream</code> must support mark and reset (see
 * {@link InputStream#markSupported()}). If it does not support mark and
 * reset, an {@link MimeException} is thrown.
 *
 * @param in
 *            the stream from which to read the data.
 * @return the mime types.
 * @throws MimeException
 *             if the specified <code>InputStream</code> does not support
 *             mark and reset (see {@link InputStream#markSupported()}).
 */
public Collection<MimeType> getMimeTypesInputStream(final InputStream in)
		throws UnsupportedOperationException {
	AppState.logX(TAG, String.format("getMimeTypesInputStream: mMagicMimeEntries.size = %d",
		mMagicMimeEntries));

	Collection<MimeType> mimeTypes = new LinkedHashSet<MimeType>();
	int len = mMagicMimeEntries.size();
	try {
		for (int i = 0; i < len; i++) {
			MagicMimeEntry me = (MagicMimeEntry) mMagicMimeEntries.get(i);
			MagicMimeEntry matchingMagicMimeEntry = me.getMatch(in);
			if (matchingMagicMimeEntry != null) {
				mimeTypes.add(matchingMagicMimeEntry.getMimeType());
			}
		}
	} catch (Exception e) {
		AppState.log(TAG, e.getMessage());
	}
	return mimeTypes;
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
private ContentType getFileMimeType(File file){

        try {
            Collection<MimeType> types = MimeUtil.getMimeTypes(file);
            MimeType target = null;
            for (MimeType mimeType : types){
                if (mimeType.equals(MimeUtil2.UNKNOWN_MIME_TYPE)){
                    continue;
                }
                target = mimeType;
            }
            if (target != null){
                return ContentType.create(target.toString());
            }
            return null;
        } catch (MimeException e) {
            logger.error(e.getMessage(), e);
            return null;
        }
    }
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
public boolean isSafeInline(MimeType type) {
  if (MimeUtil2.UNKNOWN_MIME_TYPE.equals(type)) {
    // Most browsers perform content type sniffing when they get told
    // a generic content type. This is bad, so assume we cannot send
    // the file inline.
    //
    return false;
  }

  final boolean any = isSafe(cfg, "*/*", false);
  final boolean genericMedia = isSafe(cfg, type.getMediaType() + "/*", any);
  return isSafe(cfg, type.toString(), genericMedia);
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
private BinaryResult wrapBlob(
    String path,
    final ObjectLoader obj,
    byte[] raw,
    MimeType contentType,
    @Nullable String suffix) {
  return asBinaryResult(raw, obj)
      .setContentType(contentType.toString())
      .setAttachmentName(safeFileName(path, suffix));
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Defer this call to the InputStream method
 */
public Collection<MimeType> getMimeTypesURL(final URL url) throws UnsupportedOperationException {
	InputStream in = null;
	try {
		return getMimeTypesInputStream(in = new BufferedInputStream(MimeUtil.getInputStreamForURL(url)));
	}catch(Exception e) {
		throw new MimeException(e);
	}finally {
		closeStream(in);
	}
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
public Collection getMimeTypesURL(URL url)
		throws UnsupportedOperationException {
	Collection mimeTypes = new ArrayList();
	if(!isWindows) {
		return mimeTypes;
	}

	String contentType = getContentType(MimeUtil.getExtension(url.getPath()));
	if(contentType != null && contentType.length() > 0) {
		mimeTypes.add(new MimeType(contentType));
	}
	return mimeTypes;
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
MagicMimeEntry getMatch(byte[] content) throws IOException {
	ByteBuffer buf = readBuffer(content);
	if (buf == null)
		return null;

	buf.position(0);
	boolean matches = match(buf);
	if (matches) {
		int subLen = subEntries.size();
		MimeType mimeType = getMimeType();
		if (subLen > 0) {
			for (int k = 0; k < subLen; k++) {
				MagicMimeEntry me = (MagicMimeEntry) subEntries.get(k);
				MagicMimeEntry matchingEntry = me.getMatch(content);
				if (matchingEntry != null) {
					return matchingEntry;
				}
			}
			if (mimeType != null) {
				return this;
			}
		} else {
			if (mimeType != null)
				return this;
		}
	}

	return null;
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
public static String mimeTypeGet2(Context context, String filename) {
	AppState.logX(TAG, String.format("mimeTypeGet2: filename = %s", filename));

	MimeType mimeType = UNKNOWN_MIME_TYPE;
	AppState.logX(TAG, "mimeTypeGet2: 1");
	File file = new File(filename);
	AppState.logX(TAG, "mimeTypeGet2: 2");
	if (file.isDirectory()) {
		AppState.logX(TAG, "mimeTypeGet2: 3");
		mimeType = MimeUtil2.DIRECTORY_MIME_TYPE;
		AppState.logX(TAG, "mimeTypeGet2: 4");
	} else {
		AppState.logX(TAG, "mimeTypeGet2: 5");
		MagicMimeMimeDetector detector = new MagicMimeMimeDetector(context);
		AppState.logX(TAG, "mimeTypeGet2: 6");
		Collection<MimeType> mimeTypes = new ArrayList<MimeType>();
		AppState.logX(TAG, "mimeTypeGet2: 7");
		mimeTypes.addAll(detector.getMimeTypesFileName(filename));
		AppState.logX(TAG, String.format("mimeTypeGet2: 8: mimeType.size = %d", mimeTypes.size()));
		mimeTypes.remove(UNKNOWN_MIME_TYPE);
		AppState.logX(TAG, "mimeTypeGet2: 9");
		mimeType = MimeUtil2.getMostSpecificMimeType(mimeTypes);
		AppState.logX(TAG, "mimeTypeGet2: 10");
	}

	AppState.logX(TAG, String.format("mimeTypeGet2: mimeType = %s", mimeType != null ? mimeType.toString() :
		"null"));

	return mimeType != null ? mimeType.toString() : context.getString(R.string.mime_file_text);
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Validates the content of a File Upload against this definition. Content length and type is determined and validated.
 * The UploadInfo object is updated with the determined Content Type.
 * @param pUploadInfo File Upload to be validated
 * @param pFirstPacket Variable length byte array containing the first n bytes of the file. This is used for magic MIME detection/
 * @throws ExUploadValidation If validation fails. The thrown exception will contain a more detailed reason for the
 * validation failure.
 */
public void validateContent(UploadInfo pUploadInfo, byte[] pFirstPacket)
throws ExUploadValidation {

  //Size Validation
  validateSize(pUploadInfo.getHttpContentLength());

  //Content type validation
  String lExtension = pUploadInfo.getFilename().indexOf('.') != -1 ? pUploadInfo.getFilename().substring(pUploadInfo.getFilename().lastIndexOf('.')+1) : "";
  /*
   * Magic MIME type check
   *
   * The first UploadWorkItem.BYTE_READ_QUANTITY bytes of an upload are passed to
   * the mimeutil MIME type detector (See http://sourceforge.net/projects/mime-util)
   * The magic.mime file syntax specifies fixed addresses of bytes in the file to
   * inspect, so we know that we have passed  enough of the file for the detection
   * to work. Note the custom implementation of the MagicMimeDetector - this overloads
   * the behaviour of the supplied class, which looks at various filesystem/environment
   * variable locations to find magic.mime files.
   *
   */
  Collection lMimeTypes = new MimeUtil().getMimeTypes(pFirstPacket);

  Set<String> lMimeTypeStrings = new HashSet<>();

  //log MIME type data
  for(Iterator it = lMimeTypes.iterator(); it.hasNext();){
    MimeType lMimeType = (MimeType) it.next();
    if(lMimeType != null) {
      pUploadInfo.addMagicContentType(lMimeType.toString());
      lMimeTypeStrings.add(lMimeType.toString());
    }
  }

  try {
    String lMime = getAndValidateMimeType(lExtension, pUploadInfo.getBrowserContentType(), lMimeTypeStrings);
    pUploadInfo.setTrueContentType(lMime);
  }
  catch (ExUploadValidation ex) {
    pUploadInfo.setTrueContentType(ex.getMimeType());
    throw ex;
  }
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
protected Collection<MimeType> getMimeTypesFile(File file) {
  return getMimeTypesFileName(file.getName());
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
protected Collection<MimeType> getMimeTypesURL(URL url) {
  return getMimeTypesFileName(url.getPath());
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
protected Collection<MimeType> getMimeTypesInputStream(InputStream arg0) {
  return Collections.emptyList();
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
@Override
protected Collection<MimeType> getMimeTypesByteArray(byte[] arg0) {
  return Collections.emptyList();
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
private static boolean isUnknownType(Collection<MimeType> mimeTypes) {
  if (mimeTypes.isEmpty()) {
    return true;
  }
  return mimeTypes.size() == 1 && mimeTypes.contains(MimeUtil2.UNKNOWN_MIME_TYPE);
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
public BinaryResult downloadContent(
    ProjectState project, ObjectId revstr, String path, @Nullable Integer parent)
    throws ResourceNotFoundException, IOException {
  try (Repository repo = openRepository(project);
      RevWalk rw = new RevWalk(repo)) {
    String suffix = "new";
    RevCommit commit = rw.parseCommit(revstr);
    if (parent != null && parent > 0) {
      if (commit.getParentCount() == 1) {
        suffix = "old";
      } else {
        suffix = "old" + parent;
      }
      commit = rw.parseCommit(commit.getParent(parent - 1));
    }
    ObjectReader reader = rw.getObjectReader();
    TreeWalk tw = TreeWalk.forPath(reader, path, commit.getTree());
    if (tw == null) {
      throw new ResourceNotFoundException();
    }

    int mode = tw.getFileMode(0).getObjectType();
    if (mode != Constants.OBJ_BLOB) {
      throw new ResourceNotFoundException();
    }

    ObjectId id = tw.getObjectId(0);
    ObjectLoader obj = repo.open(id, OBJ_BLOB);
    byte[] raw;
    try {
      raw = obj.getCachedBytes(MAX_SIZE);
    } catch (LargeObjectException e) {
      raw = null;
    }

    MimeType contentType = registry.getMimeType(path, raw);
    return registry.isSafeInline(contentType)
        ? wrapBlob(path, obj, raw, contentType, suffix)
        : zipBlob(path, obj, commit, suffix);
  }
}
 

import eu.medsea.mimeutil.MimeType; //导入依赖的package包/类
/**
 * Defer this call to the File method
 */
public Collection<MimeType> getMimeTypesFileName(final String fileName) throws UnsupportedOperationException {
	AppState.logX(TAG, String.format("getMimeTypesFileName: filename = %s", fileName));

	return getMimeTypesFile(new File(fileName));
}