Wie bestimme ich den MIME-Dateityp in Android?

176

Angenommen, ich habe einen vollständigen Dateipfad wie: (/ sdcard / tlogo.png). Ich möchte seinen Pantomimentyp kennen.

Ich habe eine Funktion dafür erstellt

public static String getMimeType(File file, Context context)    
{
    Uri uri = Uri.fromFile(file);
    ContentResolver cR = context.getContentResolver();
    MimeTypeMap mime = MimeTypeMap.getSingleton();
    String type = mime.getExtensionFromMimeType(cR.getType(uri));
    return type;
}

aber wenn ich es nenne, gibt es null zurück.

File file = new File(filePath);
String fileType=CommonFunctions.getMimeType(file, context);
Sushant Bhatnagar
quelle

Antworten:

323

In erster Linie sollten Sie in Betracht ziehen MimeTypeMap#getMimeTypeFromExtension(), wie folgt anzurufen:

// url = file path or whatever suitable URL you want.
public static String getMimeType(String url) {
    String type = null;
    String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return type;
}
Jens
quelle
4
danke Arbeit für mich und eine andere Lösung meines Problems ist: public static String getMimeType (Stringpfad, Kontextkontext) {String extention = path.substring (path.lastIndexOf (".")); String mimeTypeMap = MimeTypeMap.getFileExtensionFromUrl (Erweiterung); String mimeType = MimeTypeMap.getSingleton () .getMimeTypeFromExtension (mimeTypeMap); return mimeType;}
Sushant Bhatnagar
13
Und wenn die Datei nicht die gute Erweiterung hat? eine Person kann eine .mp3 machen und sie enthält Text
throrin19
2
Dann müssten Sie die Datei tatsächlich öffnen und die magische Zahl (abhängig vom Format von c) im Lead-In überprüfen - dies setzt jedoch auch voraus, dass die Person, die TXT-Dateien in MP3 umbenennt, nicht nur ID3in die Datei geschrieben hat Anfang seines Textes, um sich noch mehr mit dir anzulegen.
Jens
1
Wenn die Datei eine unbekannte Erweiterung hat. Gibt die Methode zurück */*?
3
Wenn Sie den Dateipfad / storage / emulated / 0 / Download / images (4) .jpg haben und nach dem Mimetyp fragen, wird null zurückgegeben.
Kalaiselvan
165

Ermitteln Sie den MIME-Typ einer beliebigen Datei

public String getMimeType(Uri uri) {           
    String mimeType = null;
    if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
        ContentResolver cr = getAppContext().getContentResolver();
        mimeType = cr.getType(uri);
    } else {
        String fileExtension = MimeTypeMap.getFileExtensionFromUrl(uri
                .toString());
        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
                fileExtension.toLowerCase());
    }
    return mimeType;
}
Hoa Le
quelle
5
Dies sollte die richtige Antwort sein. toLowerCase()hat den Trick gemacht.
Rajat Saxena
1
Dies ist bei weitem die beste Antwort, aber es schlägt kläglich fehl, wenn der Dateiname ein Sonderzeichen hat, in meinem Fall ein apostrophe! Z.B. Dateiname = Don't go baby.mp3. Das PatternMatcherInnere MimeTypeMap.getFileExtensionFromUrl()kann den Dateinamen nicht verarbeiten und gibt einen leeren String zurück. null ist der Mimetyp String!
Sud007
Es gibt eine ähnliche, aber fehlerfreie Lösung von I. ShvedenenkoWorked für die Probleme, auf die ich oben hingewiesen habe. Aber diese Antwort war ein Hinweis in die richtige Richtung.
Sud007
Dieser Code gibt null mit der Zeichenfolge "/ storage / emulated / 0 / dcim / keyshots / screenhot_20190319-123828_ubl digital app.jpg" zurück.
Abdul
@Abdul Es liegt daran, dass dieser Pfad kein Uri-Schema hat. Es sollte entweder mit file://oder beginnen content://.
HB.
33

Die oben genannte MimeTypeMap-Lösung hat in meiner Verwendung null zurückgegeben. Das funktioniert und ist einfacher:

Uri uri = Uri.fromFile(file);
ContentResolver cR = context.getContentResolver();
String mime = cR.getType(uri);
Jeb
quelle
19
Diese Methode kann auch null zurückgeben.
Herr Smith
Es sieht so aus, als ob es laut URI null zurückgeben kann oder nicht. Kein Körper scheint zu wissen warum ;-(
Thomas Decaux
10
Wenn das Medium aus der Android-Galerie ausgewählt ist, wird TYPE zurückgegeben. Bei Auswahl im Dateimanager wird null zurückgegeben.
Rahul Rastogi
Ich kann positiv bestätigen, was Rahul gesagt hat, habe es gerade getestet und er hat Recht
Chris
In einigen Geräten, wenn ich Bild aus der Galerie auch auswähle, gibt es null zurück
Ghanshyam Nayma
21

Optimierte Version von Jens ' Antwort mit Null-Sicherheit und Fallback-Typ.

@NonNull
static String getMimeType(@NonNull File file) {
    String type = null;
    final String url = file.toString();
    final String extension = MimeTypeMap.getFileExtensionFromUrl(url);
    if (extension != null) {
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase());
    }
    if (type == null) {
        type = "image/*"; // fallback type. You might set it to */*
    }
    return type;
}

Wichtig : getFileExtensionFromUrl () funktioniert nur mit Kleinbuchstaben !


Update (19.03.2018)

Bonus: Über Methoden als weniger ausführliche Kotlin-Erweiterungsfunktion :

fun File.getMimeType(fallback: String = "image/*"): String {
    return MimeTypeMap.getFileExtensionFromUrl(toString())
            ?.run { MimeTypeMap.getSingleton().getMimeTypeFromExtension(toLowerCase()) }
            ?: fallback // You might set it to */*
}
Tobias
quelle
das hat funktioniert. etwas zu ausführlich für meinen Geschmack.
filthy_wizard
Natürlich kann dies kürzer geschrieben werden. Mit Kotlin wahrscheinlich nur zwei oder drei Zeilen, jedoch war der Fuchs auf der Nullsicherheit und toLoverCaseTeil.
Tobias
@filthy_wizard, hat eine optimierte Version nur für dich hinzugefügt ;-)
Tobias
Was mich betrifft, ist die Verwendung der Methode getPath () anstelle von toString () klarer und der Pfad nur mit der Zugriffssyntax der Kotlin-Eigenschaften.
Leonid
15
File file = new File(path, name);

    MimeTypeMap mime = MimeTypeMap.getSingleton();
    int index = file.getName().lastIndexOf('.')+1;
    String ext = file.getName().substring(index).toLowerCase();
    String type = mime.getMimeTypeFromExtension(ext);

    intent.setDataAndType(Uri.fromFile(file), type);
    try
    {
      context.startActivity(intent);
    }
    catch(ActivityNotFoundException ex)
    {
        ex.printStackTrace();

    }
umerk44
quelle
1
Funktioniert perfekt für mich! Aber wie wäre es mit FilenameUtils.getExetension (Pfad), um die Dateierweiterung zu erhalten?
Peterb
7

Achten Sie ganz nah Aufmerksamkeit auf umerk44 ‚s Lösung oben. getMimeTypeFromExtensionruft auf guessMimeTypeTypeFromExtensionund ist CASE SENSITIVE. Ich habe einen Nachmittag damit verbracht und mich dann genauer umgesehen - getMimeTypeFromExtensionwird zurückkehren, NULLwenn Sie "JPG" übergeben, während "image / jpeg" zurückgegeben wird, wenn Sie "jpg" übergeben.

Mike Kogan
quelle
5

Hier ist die Lösung, die ich in meiner Android-App verwendet habe:

public static String getMimeType(String url)
    {
        String extension = url.substring(url.lastIndexOf("."));
        String mimeTypeMap = MimeTypeMap.getFileExtensionFromUrl(extension);
        String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(mimeTypeMap);
        return mimeType;
    }
Mahendra Liya
quelle
1
URL? Viele URLs haben keine Erweiterung. Zum Beispiel hat diese Seite keine Erweiterung. Für die URL sollten Sie die neue URL (url) .openConnection () verwenden. GetRequestProperty ("Content-type");
Barwnikk
5

Manchmal funktionieren die Antworten von Jeb und Jens nicht und geben null zurück. In diesem Fall verwende ich die Follow-Lösung. Der Dateikopf enthält normalerweise eine Typensignatur. Ich lese es und vergleiche es mit bekannten Unterschriften .

/**
 *
 * @param is InputStream on start of file. Otherwise signature can not be defined.
 * @return int id of signature or -1, if unknown signature was found. See SIGNATURE_ID_(type) constants to
 *      identify signature by its id.
 * @throws IOException in cases of read errors.
 */
public static int getSignatureIdFromHeader(InputStream is) throws IOException {
    // read signature from head of source and compare with known signatures
    int signatureId = -1;
    int sigCount = SIGNATURES.length;
    int[] byteArray = new int[MAX_SIGNATURE_LENGTH];
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < MAX_SIGNATURE_LENGTH; i++) {
        byteArray[i] = is.read();
        builder.append(Integer.toHexString(byteArray[i]));
    }
    if (DEBUG) {
        Log.d(TAG, "head bytes=" + builder.toString());
    }
    for (int i = 0; i < MAX_SIGNATURE_LENGTH; i++) {

        // check each bytes with known signatures
        int bytes = byteArray[i];
        int lastSigId = -1;
        int coincidences = 0;

        for (int j = 0; j < sigCount; j++) {
            int[] sig = SIGNATURES[j];

            if (DEBUG) {
                Log.d(TAG, "compare" + i + ": " + Integer.toHexString(bytes) + " with " + sig[i]);
            }
            if (bytes == sig[i]) {
                lastSigId = j;
                coincidences++;
            }
        }

        // signature is unknown
        if (coincidences == 0) {
            break;
        }
        // if first bytes of signature is known we check signature for full coincidence
        if (coincidences == 1) {
            int[] sig = SIGNATURES[lastSigId];
            int sigLength = sig.length;
            boolean isSigKnown = true;
            for (; i < MAX_SIGNATURE_LENGTH && i < sigLength; i++) {
                bytes = byteArray[i];
                if (bytes != sig[i]) {
                    isSigKnown = false;
                    break;
                }
            }
            if (isSigKnown) {
                signatureId = lastSigId;
            }
            break;
        }
    }
    return signatureId;
}

signatureIdist ein Signaturindex in einem Array von Signaturen. Beispielsweise,

private static final int[] SIGNATURE_PNG = hexStringToIntArray("89504E470D0A1A0A");
private static final int[] SIGNATURE_JPEG = hexStringToIntArray("FFD8FF");
private static final int[] SIGNATURE_GIF = hexStringToIntArray("474946");

public static final int SIGNATURE_ID_JPEG = 0;
public static final int SIGNATURE_ID_PNG = 1;
public static final int SIGNATURE_ID_GIF = 2;
private static final int[][] SIGNATURES = new int[3][];

static {
    SIGNATURES[SIGNATURE_ID_JPEG] = SIGNATURE_JPEG;
    SIGNATURES[SIGNATURE_ID_PNG] = SIGNATURE_PNG;
    SIGNATURES[SIGNATURE_ID_GIF] = SIGNATURE_GIF;
}

Jetzt habe ich Dateityp, auch wenn URI der Datei nicht. Als nächstes bekomme ich MIME-Typ für Dateityp. Wenn Sie nicht wissen, welchen MIME-Typ Sie erhalten sollen, finden Sie ihn in dieser Tabelle .

Es funktioniert für viele Dateitypen. Aber für Videos funktioniert es nicht, da Sie einen bekannten Video-Codec benötigen, um einen MIME-Typ zu erhalten. Um den MIME- Typ des Videos zu erhalten, verwende ich MediaMetadataRetriever .

Sergei Vasilenko
quelle
4

Ich habe versucht, Standardmethoden zu verwenden, um den MIME-Typ zu bestimmen, aber ich kann die Dateierweiterung nicht mit beibehalten MimeTypeMap.getFileExtensionFromUrl(uri.getPath()). Diese Methode gab mir eine leere Zeichenfolge zurück. Also habe ich eine nicht triviale Lösung gefunden, um die Dateierweiterung beizubehalten.

Hier ist die Methode, die die Dateierweiterung zurückgibt:

private String getExtension(String fileName){
    char[] arrayOfFilename = fileName.toCharArray();
    for(int i = arrayOfFilename.length-1; i > 0; i--){
        if(arrayOfFilename[i] == '.'){
            return fileName.substring(i+1, fileName.length());
        }
    }
    return "";
}

Und nachdem die Dateierweiterung beibehalten wurde, ist es möglich, den MIME-Typ wie folgt abzurufen:

public String getMimeType(File file) {
    String mimeType = "";
    String extension = getExtension(file.getName());
    if (MimeTypeMap.getSingleton().hasExtension(extension)) {
        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return mimeType;
}
I. Shvedenenko
quelle
Mann, das hat alle Antworten auf dieses Problem getroffen! Ich hatte das gleiche Problem mit allen Legacy-Klassen. Das Problem war das gleiche wie Sie erwähnt haben. Es wurde eine MimeTypeMap.getFileExtensionFromUrlleere Zeichenfolge für die Dateinamen zurückgegeben, die ungültige Zeichen gemäß der internen Implementierung von a haben PatternMatcher. Das hat bei mir komplett geklappt! Liebte es, bisher keine Probleme!
Sud007
@ICH. Shvedenenko String extension = file.getName().split("\\.")[1]hätte auch funktioniert und damit die Methode getExtension () eliminiert.
Shahood ul Hassan
Aber was ist, wenn beim Erstellen der Datei eine falsche Erweiterung verwendet wird? Sollte Extension der alleinige Richter des MIME-Typs sein?
Shahood ul Hassan
2

MimeTypeMapEinige Dateierweiterungen wie flv, mpeg, 3gpp, cpp werden möglicherweise nicht erkannt. Sie müssen sich also überlegen, wie Sie die MimeTypeMap erweitern können, um Ihren Code zu verwalten. Hier ist ein solches Beispiel.

http://grepcode.com/file/repo1.maven.org/maven2/com.google.okhttp/okhttp/20120626/libcore/net/MimeUtils.java#MimeUtils

Außerdem finden Sie hier eine vollständige Liste der MIME-Typen

http: //www.sitepoint.com/web-foundations/mime-types-complete-list/

Min Thant Htoo
quelle
2

Für Xamarin Android (Aus der Antwort von @ HoaLe oben)

public String getMimeType(Uri uri) {
    String mimeType = null;
    if (uri.Scheme.Equals(ContentResolver.SchemeContent))
    {
        ContentResolver cr = Application.Context.ContentResolver;
        mimeType = cr.GetType(uri);
    }
    else
    {
        String fileExtension = MimeTypeMap.GetFileExtensionFromUrl(uri.ToString());
        mimeType = MimeTypeMap.Singleton.GetMimeTypeFromExtension(
        fileExtension.ToLower());
    }
    return mimeType;
}
Neugier
quelle
1
get file object....
File file = new File(filePath);

then....pass as a parameter to...

getMimeType(file);

...here is 


public String getMimeType(File file) {
        String mimetype = MimeTypeMap.getSingleton().getMimeTypeFromExtension(MimeTypeMap.getFileExtensionFromUrl(Uri.fromFile(file).toString()).toLowerCase());
        if (mimetype == null) {
            return "*/*";
        }
        return mimetype;///return the mimeType
    }
Nilesh Panchal
quelle
1

Während von Asset / Datei (Beachten Sie, dass in der MimeTypeMap nur wenige Fälle fehlen).

private String getMimeType(String path) {
    if (null == path) return "*/*";

    String extension = path;
    int lastDot = extension.lastIndexOf('.');
    if (lastDot != -1) {
        extension = extension.substring(lastDot + 1);
    }

    // Convert the URI string to lower case to ensure compatibility with MimeTypeMap (see CB-2185).
    extension = extension.toLowerCase(Locale.getDefault());
    if (extension.equals("3ga")) {
        return "audio/3gpp";
    } else if (extension.equals("js")) {
        return "text/javascript";
    } else if (extension.equals("woff")) {
        return "application/x-font-woff";
    } else {
        // TODO
        // anyting missing from the map (http://www.sitepoint.com/web-foundations/mime-types-complete-list/)
        // reference: http://grepcode.com/file/repo1.maven.org/maven2/com.google.okhttp/okhttp/20120626/libcore/net/MimeUtils.java#MimeUtils
    }

    return MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}

Während der Verwendung von ContentResolver

contentResolver.getType(uri)

Während http / https Anfrage

    try {
        HttpURLConnection conn = httpClient.open(new URL(uri.toString()));
        conn.setDoInput(false);
        conn.setRequestMethod("HEAD");
        return conn.getHeaderField("Content-Type");
    } catch (IOException e) {
    }
WCG
quelle
1
// This will return the mimeType. 
// for eg. xyz.png it will return image/png. 
// here uri is the file that we were picked using intent from ext/internal storage.
private String getMimeType(Uri uri) {
   // This class provides applications access to the content model.  
   ContentResolver contentResolver = getContentResolver();

   // getType(Uri url)-Return the MIME type of the given content URL. 
   return contentResolver.getType(uri);
}
iamdhariot
quelle
Bitte geben Sie eine Erklärung. Dies hilft dem Erstleser, seinen Code anzupassen, und den weiteren Lesern, den größtmöglichen Nutzen aus Ihrer Antwort zu ziehen.
Aurélien B
Vielen Dank für Ihre Antwort. Ich bearbeite es mit Erklärung.
Iamdhariot
1

Ich hatte ein ähnliches Problem. Bisher weiß ich, dass das Ergebnis für verschiedene Namen unterschiedlich sein kann, also kam ich schließlich zu dieser Lösung.

public String getMimeType(String filePath) {
    String type = null;
    String extension = null;
    int i = filePath.lastIndexOf('.');
    if (i > 0)
        extension = filePath.substring(i+1);
    if (extension != null)
        type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    return type;
}  
Ashish Sahu
quelle
0

Die obige Lösung hat im Fall einer .rar-Datei null zurückgegeben, wobei URLConnection.guessContentTypeFromName (url) in diesem Fall funktioniert hat.

Luis Barragan
quelle
0

MIME aus lokaler Datei:

String url = file.getAbsolutePath();
FileNameMap fileNameMap = URLConnection.getFileNameMap();
String mime = fileNameMap.getContentTypeFor("file://"+url);
Flinbor
quelle
0

Sie haben mehrere Möglichkeiten, um eine Dateierweiterung zu erhalten: wie: 1- String filename = uri.getLastPathSegment();siehe diesen Link

2-Sie können diesen Code auch verwenden

 filePath .substring(filePath.lastIndexOf(".")+1);

aber das ist nicht gut aproch. 3-Wenn Sie einen URI der Datei haben, verwenden Sie diesen Code

String[] projection = { MediaStore.MediaColumns.DATA,
MediaStore.MediaColumns.MIME_TYPE };

4-Wenn Sie eine URL haben, verwenden Sie diesen Code:

 public static String getMimeType(String url) {
String type = null;
String extension = MimeTypeMap.getFileExtensionFromUrl(url);
if (extension != null) { 


  type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }

return type;
}

Viel Spaß mit deinem Code :)

John Smith
quelle
0
// new processing the mime type out of Uri which may return null in some cases
String mimeType = getContentResolver().getType(uri);
// old processing the mime type out of path using the extension part if new way returned null
if (mimeType == null){mimeType URLConnection.guessContentTypeFromName(path);}
Ja
quelle
0
public static String getFileType(Uri file)
{
    try
    {
        if (file.getScheme().equals(ContentResolver.SCHEME_CONTENT))
            return subStringFromLastMark(SystemMaster.getContentResolver().getType(file), "/");
        else
            return MimeTypeMap.getFileExtensionFromUrl(file.toString()).toLowerCase();
    }
    catch(Exception e)
    {
        return null;
    }
}

public static String getMimeType(Uri file)
{
    try
    {
        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(getFileType(file));
    }
    catch(Exception e)
    {
        return null;
    }
}

public static String subStringFromLastMark(String str,String mark)
{
    int l = str.lastIndexOf(mark);
    int end = str.length();
    if(l == -1)
        return str;

    return str.substring(l + 1, end);
}
Ali Bagheri
quelle
0

Hat auch in meinem Fallpfad null Wert zurückgegeben

/ storage / emulated / 0 / Music / 01 - Geist auf der Tanzfläche.mp3

als Workaround verwenden

val url = inUrl.replace ("", "")

So sieht die Methode aus

@JvmStatic
    fun getMimeType(inUrl: String?): String {
        if (inUrl == null) return ""

        val url = inUrl.replace(" ","")
        var type: String? = null

        val extension = MimeTypeMap.getFileExtensionFromUrl(url)
        if (extension != null) {
            type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension.toLowerCase())
        }

        if(type ==null){
            val cR = WifiTalkie.getApplicationContext().contentResolver
            type = cR.getType(Uri.parse(url))
        }

        if (type == null) {
            type = "*/*" // fallback method_type. You might set it to */*
        }
        return type
    }

als Ergebnis gibt es Erfolgsergebnis zurück:

Audio / MPEG

Hoffe es hilft jedem

Serg Burlaka
quelle
0

Keine der Antworten hier ist perfekt. Hier ist eine Antwort, die die besten Elemente aller Top-Antworten kombiniert:

public final class FileUtil {

    // By default, Android doesn't provide support for JSON
    public static final String MIME_TYPE_JSON = "application/json";

    @Nullable
    public static String getMimeType(@NonNull Context context, @NonNull Uri uri) {

        String mimeType = null;
        if (uri.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
            ContentResolver cr = context.getContentResolver();
            mimeType = cr.getType(uri);
        } else {
            String fileExtension = getExtension(uri.toString());

            if(fileExtension == null){
                return null;
            }

            mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(
                    fileExtension.toLowerCase());

            if(mimeType == null){
                // Handle the misc file extensions
                return handleMiscFileExtensions(fileExtension);
            }
        }
        return mimeType;
    }

    @Nullable
    private static String getExtension(@Nullable String fileName){

        if(fileName == null || TextUtils.isEmpty(fileName)){
            return null;
        }

        char[] arrayOfFilename = fileName.toCharArray();
        for(int i = arrayOfFilename.length-1; i > 0; i--){
            if(arrayOfFilename[i] == '.'){
                return fileName.substring(i+1, fileName.length());
            }
        }
        return null;
    }

    @Nullable
    private static String handleMiscFileExtensions(@NonNull String extension){

        if(extension.equals("json")){
            return MIME_TYPE_JSON;
        }
        else{
            return null;
        }
    }
}
Manish Kumar Sharma
quelle
0
Intent myIntent = new Intent(android.content.Intent.ACTION_VIEW);
                        File file = new File(filePatch); 
                        Uri uris = Uri.fromFile(file);
                        String mimetype = null;
                        if 
(uris.getScheme().equals(ContentResolver.SCHEME_CONTENT)) {
                            ContentResolver cr = 
getApplicationContext().getContentResolver();
                            mimetype = cr.getType(uris);
                        } else {
                            String fileExtension = 
MimeTypeMap.getFileExtensionFromUrl(uris.toString());
mimetype =  MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension.toLowerCase());
                        }
Роман Зыков
quelle
0

Ich weiß nicht, warum MimeTypeMap.getFileExtensionFromUrl()es Probleme mit spaces und einigen anderen Zeichen gibt, die zurückkehren "", aber ich habe gerade diese Methode geschrieben, um den Dateinamen in einen zulässigen zu ändern. Es spielt nur mit Strings. Es funktioniert jedoch irgendwie. Durch das Verfahren wird das spaceim Dateinamen vorhandene s in ein wünschenswertes Zeichen (das hier "x" ist) über replaceAll(" ", "x")und andere ungeeignete Zeichen in ein geeignetes über umgewandelt URLEncoder. Daher sollte die Verwendung (gemäß den in der Frage angegebenen Codes und der ausgewählten Antwort) ungefähr so ​​sein getMimeType(reviseUrl(url)).

private String reviseUrl(String url) {

        String revisedUrl = "";
        int fileNameBeginning = url.lastIndexOf("/");
        int fileNameEnding = url.lastIndexOf(".");

        String cutFileNameFromUrl = url.substring(fileNameBeginning + 1, fileNameEnding).replaceAll(" ", "x");

        revisedUrl = url.
                substring(0, fileNameBeginning + 1) +
                java.net.URLEncoder.encode(cutFileNameFromUrl) +
                url.substring(fileNameEnding, url.length());

        return revisedUrl;
    }
elyar abad
quelle