Android में MIME प्रकार की फ़ाइल कैसे निर्धारित करें?


176

मान लीजिए कि मेरे पास फ़ाइल का पूर्ण पथ है: (/ sdcard / tlogo.png)। मैं इसका माइम प्रकार जानना चाहता हूं।

मैंने इसके लिए एक फंक्शन बनाया

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;
}

लेकिन जब मैं इसे कॉल करता हूं, तो यह अशक्त हो जाता है।

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

जवाबों:


323

सबसे पहले और सबसे महत्वपूर्ण, आपको MimeTypeMap#getMimeTypeFromExtension()इस तरह से कॉल करने पर विचार करना चाहिए :

// 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;
}

4
मेरे लिए धन्यवाद काम और मेरी समस्या का एक और समाधान है: सार्वजनिक स्थैतिक स्ट्रिंग getMimeType (स्ट्रिंग पथ, संदर्भ प्रसंग) {स्ट्रिंग extention = path.substring (path.lastIndexOf ("।"))। स्ट्रिंग mimeTypeMap = MimeTypeMap.getFileExtensionFromUrl (extention); स्ट्रिंग mimeType = MimeTypeMap.getSingleton () .getMimeTypeFromExtension (mimeTypeMap); वापसी mimeType;}
सुशांत भटनागर

13
और अगर फ़ाइल का अच्छा विस्तार नहीं है? एक व्यक्ति .mp3 बना सकता है और इसमें टेक्स्ट
थ्रोरिन 19

2
इस, तथापि, यह भी मानता है कि व्यक्ति एमपी 3 करने के लिए txt-फ़ाइलों का नाम बदलने बस नहीं लिखा था - तो फिर तुम वास्तव में फ़ाइल को खोलने और जादुई संख्या की जाँच नेतृत्व में में (प्रारूप ऑप्टिकल फाइबर केबल के आधार पर) की जरूरत होगी ID3में आपके साथ और भी गड़बड़ करने के लिए उनके पाठ की शुरुआत।
जेन

1
यदि फ़ाइल में कोई अज्ञात एक्सटेंशन है। क्या विधि वापसी */*?

3
यदि आपकी फ़ाइल पथ के रूप में / स्टोरेज / एमुलेटेड / 0 / डाउनलोड / इमेज (4) .jpg है और आप mimetype के लिए पूछते हैं, तो यह अशक्त है।
कालिसेलवन

165

किसी भी फ़ाइल के माइम प्रकार का पता लगाएं

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;
}

5
यह सही उत्तर होना चाहिए। toLowerCase()चाल चली।
रजत सक्सेना

1
यह अब तक का सबसे अच्छा जवाब है लेकिन यह बुरी तरह से विफल हो जाता है अगर फ़ाइल नाम में एक विशेष चरित्र है, मेरे मामले में apostrophe! उदाहरण के लिए। फ़ाइल का नाम = Don't go baby.mp3PatternMatcherअंदर MimeTypeMap.getFileExtensionFromUrl()फ़ाइल नाम नहीं संभाल और खाली स्ट्रिंग रिटर्न कर सकते हैं; नल mimetype स्ट्रिंग होने के लिए बाहर आता है!
सूद

I. Shvedenenkoजिन मुद्दों को मैंने ऊपर बताया है, उनके लिए नीचे एक समान लेकिन त्रुटि मुक्त समाधान है। लेकिन यह उत्तर सही दिशा में एक संकेतक था।
सुड 007

यह कोड स्ट्रिंग "/ संग्रहण / उत्सर्जित / 0 / dcim / स्क्रीनशॉट / स्क्रीनशॉट_20190319-123828_ubl digital app.jpg" के साथ शून्य देता है।
अब्दुल

@ अब्दुल ऐसा इसलिए है क्योंकि उस रास्ते पर उड़ी योजना नहीं है। यह या तो के साथ शुरू होना चाहिए file://या content://
एचबी।

33

ऊपर दिया गया MimeTypeMap समाधान मेरे उपयोग में शून्य है। यह काम करता है, और आसान है:

Uri uri = Uri.fromFile(file);
ContentResolver cR = context.getContentResolver();
String mime = cR.getType(uri);

19
यह विधि अशक्त भी लौट सकती है।
मिस्टर स्मिथ

ऐसा लग रहा है कि यूआरआई के अनुसार, यह अशक्त हो सकता है या नहीं। किसी भी शरीर को यह पता नहीं लगता कि क्यों?
थॉमस

10
अगर मीडिया को एंड्रॉइड गैलरी से चुना जाता है तो TYPE वापस आ जाता है। यदि फ़ाइल प्रबंधक से चुना जाता है, तो नल वापस आ जाता है।
राहुल रस्तोगी

मैं सकारात्मक रूप से पुष्टि कर सकता हूं कि राहुल ने क्या कहा, बस इसका परीक्षण किया और वह सही है
क्रिस

कुछ उपकरणों में यदि मैं गैलरी से छवि का चयन करता हूं तो यह अशक्त है
घनश्याम नयमा

21

Jens 'के ऑप्टिमाइज्ड वर्जन null-safety और फॉलबैक-टाइप के साथ उत्तर देते हैं।

@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;
}

महत्वपूर्ण : getFileExtensionFromUrl () केवल लोअरकेस के साथ काम करता है !


अपडेट (19.03.2018)

बोनस: उपरोक्त विधियाँ एक कम क्रिया के रूप में Kotlin एक्सटेंशन फ़ंक्शन :

fun File.getMimeType(fallback: String = "image/*"): String {
    return MimeTypeMap.getFileExtensionFromUrl(toString())
            ?.run { MimeTypeMap.getSingleton().getMimeTypeFromExtension(toLowerCase()) }
            ?: fallback // You might set it to */*
}

यह काम किया। हालांकि मेरी पसंद के लिए थोड़ा वर्बोज़।
गंदी_विलास

बेशक यह छोटे तरीके से गलत हो सकता है। कोटलिन के साथ शायद केवल दो या तीन लाइनें थीं, हालांकि लोमड़ी अशक्त सुरक्षा और toLoverCaseभाग पर थी।
टोबियास

@filthy_wizard, ने सिर्फ आपके लिए एक अनुकूलित संस्करण जोड़ा; ;-)
तोबियास

मेरे लिए के रूप में getPath () विधि का उपयोग करने के बजाय toString () अधिक स्पष्ट है, और सिर्फ kotlin संपत्ति का उपयोग वाक्यविन्यास का उपयोग कर पथ।
लियोनिद

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();

    }

1
मेरे लिए एकदम सही काम करता है! लेकिन फ़ाइल एक्सटेंशन पाने के लिए FilenameUtils.getExetension (पथ) का उपयोग कैसे करें?
पीटरब

7

ऊपर umerk44 के समाधान के लिए सुपर करीब ध्यान देना । getMimeTypeFromExtensionआक्रमण करता है guessMimeTypeTypeFromExtensionऔर मामला संवेदनशील है। मैं यह तो करीब से देख ले लिया एक दोपहर खर्च - getMimeTypeFromExtensionवापस आ जाएगी NULLअगर आप इसे "जेपीजी" जबकि यह "image / jpeg" वापसी यदि आप इसे "jpg" पारित करेंगे गुजरती हैं।


5

यहाँ समाधान है जो मैंने अपने एंड्रॉइड ऐप में उपयोग किया है:

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;
    }

1
यूआरएल? बहुत सारे url में एक्सटेंशन नहीं है। उदाहरण के लिए इस पृष्ठ में विस्तार नहीं है। Url के लिए आपको नए URL (url) .openConnection ()। GetRequestProperty ("सामग्री-प्रकार") का उपयोग करना चाहिए;
बार्वनिक

5

कभी-कभी जेब और जेन्स के जवाब काम नहीं करते हैं और अशक्त लौट आते हैं। इस मामले में मैं अनुवर्ती समाधान का उपयोग करता हूं। फ़ाइल के प्रमुख में आमतौर पर टाइप हस्ताक्षर होते हैं। मैंने इसे पढ़ा और हस्ताक्षर की सूची में ज्ञात के साथ तुलना की

/**
 *
 * @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;
}

signatureIdहस्ताक्षर की सरणी में हस्ताक्षर का एक सूचकांक है। उदाहरण के लिए,

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;
}

अब मेरे पास फाइल टाइप है भले ही फाइल का URI नहीं है। अगले मैं फ़ाइल प्रकार से माइम प्रकार मिलता है। यदि आप नहीं जानते कि किस प्रकार का माइम प्राप्त करना है, तो आप इस तालिका में उचित पा सकते हैं ।

यह बहुत सारे फ़ाइल प्रकारों के लिए काम करता है। लेकिन वीडियो के लिए यह काम नहीं करता है, क्योंकि आपको माइम प्रकार प्राप्त करने के लिए ज्ञात वीडियो कोडेक की आवश्यकता है। वीडियो के माइम प्रकार प्राप्त करने के लिए मैं MediaMetadataRetriever का उपयोग करता हूं ।


4

मैंने माइम प्रकार को निर्धारित करने के लिए मानक तरीकों का उपयोग करने की कोशिश की, लेकिन मैं फ़ाइल एक्सटेंशन का उपयोग करके उसे बनाए नहीं रख सकता MimeTypeMap.getFileExtensionFromUrl(uri.getPath())। इस विधि ने मुझे एक खाली स्ट्रिंग लौटा दी। इसलिए मैंने फ़ाइल एक्सटेंशन को बनाए रखने के लिए एक गैर-तुच्छ समाधान किया।

यहाँ फ़ाइल एक्सटेंशन लौटाने की विधि है:

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 "";
}

और फ़ाइल एक्सटेंशन को बनाए रखने के लिए, नीचे की तरह माइम प्राप्त करना संभव है:

public String getMimeType(File file) {
    String mimeType = "";
    String extension = getExtension(file.getName());
    if (MimeTypeMap.getSingleton().hasExtension(extension)) {
        mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
    }
    return mimeType;
}

यार, इस समस्या पर यहाँ पोस्ट किए गए सभी उत्तर! मैं सभी लिगेसी वर्गों के साथ एक ही मुद्दा था। मुद्दा वही था जैसा आपने उल्लेख किया है, MimeTypeMap.getFileExtensionFromUrlफाइलनाम के लिए खाली स्ट्रिंग लौटा दिया है, जिसमें आंतरिक कार्यान्वयन के अनुसार अमान्य वर्ण हैं PatternMatcher। यह मेरे लिए पूरी तरह से काम करता है! यह पसंद है, अब तक कोई मुद्दा नहीं!
1800 पर sud007

@मैं। Shvedenenko String extension = file.getName().split("\\.")[1]भी काम किया होगा, जिससे, getExtension () विधि को नष्ट करने।
शैडल उल हसन

लेकिन बात यह है कि यदि फ़ाइल बनाते समय एक गलत एक्सटेंशन का उपयोग किया जाता है, तो क्या होगा? क्या विस्तार को माइम प्रकार का एकमात्र न्यायाधीश होना चाहिए?
शैडल उल हसन

2

MimeTypeMapकुछ फ़ाइल एक्सटेंशन जैसे flv, mpeg, 3Gpp, cpp को नहीं पहचान सकते हैं। तो आपको यह सोचने की ज़रूरत है कि अपने कोड को बनाए रखने के लिए MimeTypeMap का विस्तार कैसे करें। यहाँ एक ऐसा उदाहरण है।

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

साथ ही, यहां माइम प्रकारों की पूरी सूची दी गई है

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


2

के लिए Xamarin एंड्रॉयड (@ ऊपर HoaLe के जवाब से)

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;
}

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
    }

1

परिसंपत्ति / फ़ाइल से (ध्यान दें कि कुछ मामलों में MimeTypeMap से गायब है)।

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);
}

जबकि ContentResolver का उपयोग करें

contentResolver.getType(uri)

जबकि http / https अनुरोध

    try {
        HttpURLConnection conn = httpClient.open(new URL(uri.toString()));
        conn.setDoInput(false);
        conn.setRequestMethod("HEAD");
        return conn.getHeaderField("Content-Type");
    } catch (IOException e) {
    }

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);
}

कृपया कुछ स्पष्टीकरण दें। यह प्रारंभिक पाठक को उसके / उसके कोड और आगे के पाठकों को आपके उत्तर से अधिकतम मूल्य दिलाने में मदद करेगा।
औरेलीन बी

आपके प्रतिक्रिया के लिए धन्येवाद। मैं इसे स्पष्टीकरण के साथ संपादित करता हूं।
इम्दरहोट 3

1

मुझे भी ऐसी ही समस्या का सामना करना पड़ा। अब तक मुझे पता है कि परिणाम अलग-अलग नामों के लिए भिन्न हो सकते हैं, इसलिए अंत में इस समाधान के लिए आया था।

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;
}  

0

उपरोक्त समाधान ने .rar फ़ाइल के मामले में null लौटाया, इस मामले में URLConnection.guessContentTypeFromName (url) का उपयोग किया।


0

स्थानीय फ़ाइल से माइम:

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

0

आपके पास फ़ाइल का विस्तार पाने के लिए कई विकल्प हैं: जैसे: 1- String filename = uri.getLastPathSegment();इस लिंक को देखें

2-आप इस कोड का भी उपयोग कर सकते हैं

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

लेकिन यह अच्छा aproch नहीं है। 3-अगर आपके पास फाइल का URI है तो इस कोड का उपयोग करें

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

4-यदि आपके पास URL है तो इस कोड का उपयोग करें:

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


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

return type;
}

अपने कोड का आनंद लें :)


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);}

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);
}

0

मेरे मामले में भी अशक्त मूल्य वापस आ गया है

/ स्टोरेज / एमुलेटेड / 0 / म्यूज़िक / 01 - घोस्ट ऑन द डांस फ्लोर .mp3

उपयोग के आसपास काम के रूप में

वैल url = inUrl.replace ("", "")

तो विधि की तरह लग रहा है

@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
    }

परिणाम के रूप में यह सफलता परिणाम लौटाता है:

ऑडियो / एमपीईजी

आशा है कि यह किसी की मदद करता है


0

यहां कोई भी जवाब सही नहीं है। यहाँ सभी शीर्ष उत्तरों के सर्वोत्तम तत्वों को मिलाकर एक उत्तर दिया गया है:

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;
        }
    }
}

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());
                        }


0

मुझे पता नहीं क्यों MimeTypeMap.getFileExtensionFromUrl()समस्याओं के साथ हैspace एस और कुछ अन्य पात्रों के , जो रिटर्न करता है "", लेकिन मैंने फ़ाइल नाम को एडमिट-सक्षम करने के लिए बदलने के लिए यह विधि लिखी है। यह सिर्फ Stringएस के साथ खेल रहा है । हालाँकि, यह काम करता है। विधि के माध्यम से, spaceफ़ाइल नाम में मौजूद s को एक वांछनीय वर्ण में बदल दिया जाता है (जो, यहाँ, "x" है) के माध्यम से replaceAll(" ", "x")और अन्य अनुपयुक्त वर्णों को एक उपयुक्त एक के माध्यम से बदल दिया जाता है URLEncoder। इसलिए उपयोग (प्रश्न में प्रस्तुत कोड के अनुसार और चयनित उत्तर) कुछ ऐसा होना चाहिए 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;
    }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.