एंड्रॉइड में स्क्रीन घनत्व प्रोग्रामिक रूप से प्राप्त कर रहा है?

Question

एंड्रॉइड में प्रोग्राम को स्क्रीन घनत्व कैसे प्राप्त करें?

मेरा मतलब है: वर्तमान डिवाइस की स्क्रीन डीपीआई कैसे खोजें?

Comments

कई उत्तर संदर्भित करते हैं getDisplayMetrics().xdpi, जो डिवाइस के वास्तविक डीपीआई को वापस करना है। कृपया ध्यान दें कि यह मान निर्माताओं द्वारा उपकरणों के पार लगातार सही तरीके से सेट नहीं किया गया है, इसलिए आप बस उनका उपयोग नहीं कर सकते । दु: खद लेकिन सच: असली डीपीआई के बारे में जानकारी उपलब्ध नहीं है । स्रोत: groups.google.com/d/msg/android-developers/g56jV0Hora0/...

— sulai

getResources().getDisplayMetrics().xdpiऔर getResources().getDisplayMetrics().ydpiआपको वास्तविक क्षैतिज और ऊर्ध्वाधर घनत्व प्रदान करेगा , जो कि अधिकांश मामलों में भिन्न हैं।

— .मेगा

Answer 1

आप से प्रदर्शन पर जानकारी प्राप्त कर सकते DisplayMetrics struct:

DisplayMetrics metrics = getResources().getDisplayMetrics();

हालांकि एंड्रॉइड एक प्रत्यक्ष पिक्सेल मैपिंग का उपयोग नहीं करता है, लेकिन यह एक मुट्ठी भर मात्रा में घनत्व स्वतंत्र पिक्सेल मूल्यों का उपयोग करता है और फिर वास्तविक स्क्रीन आकार के लिए स्केल करता है। तो metrics.densityDpiसंपत्ति में से एक होगी DENSITY_xxxस्थिरांक ( 120, 160, 213, 240, 320, 480या 640डीपीआई)।

आप की जरूरत है वास्तविक (शायद एक ओपन अनुप्रयोग के लिए) एलसीडी पिक्सेल घनत्व आप से प्राप्त कर सकते हैं metrics.xdpiऔर metrics.ydpiक्रमश: क्षैतिज और ऊर्ध्वाधर घनत्व के लिए गुण।

यदि आप 4. से पहले एपीआई स्तर को लक्षित कर रहे हैं, तो metrics.densityसंपत्ति संदर्भ घनत्व (160 डीपीआई) से एक अस्थायी बिंदु स्केलिंग कारक है। अब प्रदान किए गए समान मूल्य की metrics.densityDpiगणना की जा सकती है

int densityDpi = (int)(metrics.density * 160f);

Comments

दी गई यह पोस्ट दो साल पहले से है, लेकिन यह पहली चीज है जो इस खोज के लिए Google पर आती है, इसलिए जो कोई भी इसे पाता है, उसके लिए अब आपको 160 से गुणा नहीं करना होगा।

— roboguy12

अब किस संस्करण से नहीं?

— TacB0s

मैंने नवीनतम एपीआई संशोधनों का मिलान करने के लिए उत्तर अपडेट किया है जो लोग उपयोग कर रहे हैं।

— जोशरीरी

नोट: आप इसके बजाय इस नए एपीआई चाहते हैं: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); यह आधिकारिक तौर पर एपीआई 17 में जोड़ा गया था, लेकिन मुझे यह जानकर आश्चर्य हुआ कि यह 4.0 डिवाइस पर भी सही ढंग से काम करता है जो मैंने कोशिश की थी।

— बेंक

वहाँ भी है। स्रोत ()। getDisplayMetrics ()। घनत्वDpi

— amorenew

Answer 2

यह भी काम करता है:

 getResources().getDisplayMetrics().density;

यह आपको देगा:

0.75 - एलडीपीआई

1.0 - mdpi

1.5 - एचडीपीआई

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

रेफरी: घनत्व

रेफ २

Comments

+1 यह तब काम करता है जब आपके पास सीधी पहुंच नहीं होती है WindowManager(जैसे लोडर के अंदर)। बस इसे 160 से गुणा करें

— Michał K

एपीआई स्तर 16 ने xxdpi को जोड़ा, जो यहाँ 3.0 में अनुवाद करता है।

— क्यूईडी

इसके लिए 1.3312501 देंगे tvdpi। अधिक जानकारी के tvdpiलिए यहां

— डोरी

Nexus 7 की रिपोर्ट 1.3, क्यों ब्रैकेट में जाना चाहिए?

— नील

@selbie, आपका फोन संभवतः उच्च गुणवत्ता वाले संसाधनों को खींच रहा है और बढ़ा रहा है क्योंकि आपका फोन दो परिभाषित घनत्वों के बीच आधा रास्ता बता रहा है।

— साकिबॉय

Answer 3

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

switch(metrics.densityDpi) {
     case DisplayMetrics.DENSITY_LOW:
         break;

     case DisplayMetrics.DENSITY_MEDIUM:
         break;

     case DisplayMetrics.DENSITY_HIGH:
         break;
}

यह एपीआई स्तर 4 और उच्चतर पर काम करेगा।

Comments

आप नेक्सस 7 जैसे उपकरणों को कैसे संभालेंगे जो घनत्व 3 को 213 के रूप में रिपोर्ट करता है।

— नील

घनत्व-मान के बीच अगर-और हाथ की जाँच हो, तो (मेट्रिक्स। डेंसिटी डीपीआई> DisplayMetrics.DENSITY_LOW && मेट्रिक्स। डेंसिटी डीपीआई <DisplayMetrics.DENSITY_MEDIUM)

— मितुल नाकुम

या यदि (मेट्रिक्स। डेंसिटी डीपीआई <DisplayMetrics.DENSITY_LOW) {} या तो और (मेट्रिक्स। डेंसिटी डीपीआई <डिस्प्लेमेटिक्स। डेंसिटी_मेडियम) {} .....

— मितुल नाकुम

नील, 213 को टीवी डीपीआई कहा जाता है, उस डेंसिटी_टीवी के लिए एक नामित प्रदर्शन मैट्रिक्स घनत्व है।

— एंड्रयू एस

Answer 4

एक स्थिर सहायक विधि के रूप में ब्लंडेल का उत्तर:

private static String getDensityName(Context context) {
    float density = context.getResources().getDisplayMetrics().density;
    if (density >= 4.0) {
        return "xxxhdpi";
    }
    if (density >= 3.0) {
        return "xxhdpi";
    }
    if (density >= 2.0) {
        return "xhdpi";
    }
    if (density >= 1.5) {
        return "hdpi";
    }
    if (density >= 1.0) {
        return "mdpi";
    }
    return "ldpi";
}

Comments

tvdpi घनत्व के बारे में क्या। मेरा अनुमान है कि यह १.३३

— अनूप

@AnoopssGolden यह वास्तव में मानक नहीं है, इसलिए आप चाहें तो इसे जोड़ सकते हैं, लेकिन मुझे नहीं लगता कि उत्तर में इसे शामिल करना चाहिए। एंड्रॉइड डॉक्स से: "इसे" प्राथमिक "घनत्व समूह नहीं माना जाता है। यह ज्यादातर टेलीविज़न के लिए अभिप्रेत है और अधिकांश ऐप की आवश्यकता नहीं होनी चाहिए"।

— क्वर्टीजगुई

लेकिन नेक्सस 7 डिवाइस tvdpi घनत्व समूह से संबंधित है।

— अनूप

मुझे पता है कि यह थोड़ा पुराना है लेकिन सिर्फ जोड़ना है; MDPI एक Nexus 7 पर अधिकांश चीजों के लिए काम कर सकता है, लेकिन जैसा कि मैं अब कोशिश कर रहा हूं, MDPI के रूप में नीचे आने वाली छवियां बहुत बड़ी नहीं हैं। मुझे टीवीडीपीआई को परिभाषित करना है और फिर अपने सर्वर से एक बड़ी छवि का आकार पूछना है। यह बहुत इस्तेमाल नहीं किया जा सकता है लेकिन इसका मतलब यह नहीं है कि एमडीपीआई सब कुछ उठा लेगा।

— RED_

अरे @Andrew S, elses का उपयोग करने से कोड की दक्षता के लिए कुछ भी नहीं बदलता है क्योंकि हर अगर तुरंत वापस आ जाता है। ब्रेसिज़ निकालना केवल शैली का प्रश्न है और कोड को बनाए रखने पर IMHO इसे अधिक त्रुटि वाला बनाता है।

— क्वर्टज़्गुई

Answer 5

इसे इस्तेमाल करे:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;

Comments

मुझे यह बहुत अच्छा लगता है क्योंकि यह गतिविधि के बजाय संदर्भ पर निर्भर करता है।

— greg7gkb

सहमत, मैं इसे Viewऔर अधिक आसानी से उपयोग कर सकता हूं (जो कि जहां मुझे इसकी आवश्यकता है!)

— एंड्रयू व्याल

Answer 6

डीपीआई पाने के लिए:

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);

// will either be DENSITY_LOW, DENSITY_MEDIUM or DENSITY_HIGH
int dpiClassification = dm.densityDpi;

// these will return the actual dpi horizontally and vertically
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

Comments

dm.densityDpi रिटर्न या तो DENSITY_LOW या DENSITY_MEDIUM या DENSITY_HIGH। Xhdpi के बारे में क्या? क्या कोई DENSITY_XHIGH या ऐसा है?

— यूजीन चुमक

हाँ, वहाँ है: developer.android.com/reference/android/util/…

— caw

Answer 7

यहाँ घनत्व स्थिरांक हैं, स्रोत :

मानक घनत्व के अलावा, 5 मध्यवर्ती हैं। इस तथ्य को ध्यान में रखते हुए, निम्नलिखित कोड एक पूर्ण कार्य उदाहरण होगा:

float density = getResources().getDisplayMetrics().density;

if (density == 0.75f)
{
    // LDPI
}
else if (density >= 1.0f && density < 1.5f)
{
    // MDPI
}
else if (density == 1.5f)
{
    // HDPI
}
else if (density > 1.5f && density <= 2.0f)
{
    // XHDPI
}
else if (density > 2.0f && density <= 3.0f)
{
    // XXHDPI
}
else
{
    // XXXHDPI 
}

वैकल्पिक रूप से, आप घनत्व स्थिरांक का उपयोग करके पा सकते हैं densityDpi:

int densityDpi = getResources().getDisplayMetrics().densityDpi;

switch (densityDpi)
{
    case DisplayMetrics.DENSITY_LOW:
        // LDPI
        break;

    case DisplayMetrics.DENSITY_MEDIUM:
        // MDPI
        break;

    case DisplayMetrics.DENSITY_TV:
    case DisplayMetrics.DENSITY_HIGH:
        // HDPI
        break;

    case DisplayMetrics.DENSITY_XHIGH:
    case DisplayMetrics.DENSITY_280:
        // XHDPI
        break;

    case DisplayMetrics.DENSITY_XXHIGH:
    case DisplayMetrics.DENSITY_360:
    case DisplayMetrics.DENSITY_400:
    case DisplayMetrics.DENSITY_420:
        // XXHDPI
        break;

    case DisplayMetrics.DENSITY_XXXHIGH:
    case DisplayMetrics.DENSITY_560:
        // XXXHDPI
        break;
}

Answer 8

निम्नलिखित उत्तर qwertzguy के उत्तर के आधार पर एक छोटा सुधार है।

double density = getResources().getDisplayMetrics().density;
if (density >= 4.0) {
   //"xxxhdpi";
}
else if (density >= 3.0 && density < 4.0) {
   //xxhdpi
}
else if (density >= 2.0) {
   //xhdpi
}
else if (density >= 1.5 && density < 2.0) {
   //hdpi
}
else if (density >= 1.0 && density < 1.5) {
   //mdpi
}

Comments

यह कोड कुछ योगों के साथ कर सकता है, और यह बेमानी होने के बाद एम्परसेंड और शर्तें।

— एंड्रयू एस

@ और, सुधार के लिए धन्यवाद। मैंने उसी के अनुसार उत्तर संपादित किया है।

— सैन

@San आपको उन शर्तों में से किसी में && की आवश्यकता नहीं है, जब तक कि आपने लगातार> = के लिए जाँच की हो अन्यथा जो पहली शर्त के लिए समाप्त होगी वह सत्य है।

— dbenson

यह मेरे Nexus 5X (एक डिफ़ॉल्ट Google डिवाइस btw) के साथ मेरे लिए एक सही परिणाम नहीं लौटाता है। डिवाइस घनत्व xxhdpi है, और लौटाया गया डबल घनत्व लगभग 2.6 है।

— तोबलीग

Answer 9

यदि आप वास्तविक प्रदर्शन डीपीआई लेना चाहते हैं तो वास्तविक रूप से इसका उत्तर बीच में है यदि आप प्रदर्शन मैट्रिक्स के लिए क्वेरी करते हैं:

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int dpiClassification = dm.densityDpi;
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

घनत्वडापी * 160 आपको मूल्य / सुझाव देगा कि आपको किस घनत्व का उपयोग करना चाहिए

0.75 - ldpi - 120 dpi
1.0 - mdpi - 160 dpi
1.5 - hdpi - 240 dpi
2.0 - xhdpi - 320 dpi
3.0 - xxhdpi - 480 dpi
4.0 - xxxhdpi - 640 dpi

जैसा कि पिछले पोस्टों में बताया गया है

लेकिन dm.xdpiआप हमेशा दिए गए प्रदर्शन की वास्तविक डीपीआई नहीं देंगे : उदाहरण:

Device: Sony ericsson xperia mini pro (SK17i)
Density: 1.0 (e.g. suggests you use 160dpi resources)
xdpi: 193.5238
Real device ppi is arround 193ppi


Device: samsung GT-I8160 (Samsung ace 2)
Density 1.5 (e.g. suggests you use 240dpi resources)
xdpi 160.42105
Real device ppi is arround 246ppi

तो शायद प्रदर्शन का वास्तविक डीपीआई घनत्व * xdpi होना चाहिए .. लेकिन मुझे यकीन नहीं है कि यह करने का सही तरीका है!

Comments

घनत्व का उपयोग करना * xdpi पिछले 6 महीनों से Google Play पर मेरे सभी ऐप्स पर अब तक पूरी तरह से काम कर रहा है

— मरे हल्लो

गुणा घनत्व * xdpi तार्किक नहीं है, जो अब स्पष्ट है कि अधिक उच्च घनत्व वाले उपकरण हैं - घनत्व और xdpi दोनों बढ़ते हैं, इसलिए उन्हें गुणा करना वृद्धि को दोगुना करना होगा। मैं कहूंगा कि सैमसंग इक्का 2 विक्रेता द्वारा एक त्रुटि थी। Android कल्पना यह है कि xdpi और ydpi असली पिक्सेल घनत्व हैं - किसी भी चीज़ से गुणा न करें।

— टूलमेकरसेव

Answer 10

यह आपकी गतिविधि पर मदद करनी चाहिए ...

void printSecreenInfo(){

    Display display = getWindowManager().getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    display.getMetrics(metrics);

    Log.i(TAG, "density :" +  metrics.density);

    // density interms of dpi
    Log.i(TAG, "D density :" +  metrics.densityDpi);

    // horizontal pixel resolution
    Log.i(TAG, "width pix :" +  metrics.widthPixels);

     // actual horizontal dpi
    Log.i(TAG, "xdpi :" +  metrics.xdpi);

    // actual vertical dpi
    Log.i(TAG, "ydpi :" +  metrics.ydpi);

}

OUTPUT:

I/test( 1044): density :1.0

I/test( 1044): D density :160

I/test( 1044): width pix :800

I/test( 1044): xdpi :160.0

I/test( 1044): ydpi :160.42105

Answer 11

public static String getDensity(Context context) {
    String r;
    DisplayMetrics metrics = new DisplayMetrics();

    if (!(context instanceof Activity)) {
        r = "hdpi";
    } else {
        Activity activity = (Activity) context;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        if (metrics.densityDpi <= DisplayMetrics.DENSITY_LOW) {
            r = "ldpi";
        } else if (metrics.densityDpi <= DisplayMetrics.DENSITY_MEDIUM) {
            r = "mdpi";
        } else {
            r = "hdpi";
        }
    }

    return r;
}

Answer 12

यदि आप किसी सेवा से घनत्व प्राप्त करना चाहते हैं तो यह इस तरह से काम करता है:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);

Comments

इसने मेरी मदद की जब मेरे पास कोई खिड़कीवाला नहीं था

— silentsudo

Answer 13

आपको यह कोशिश करनी चाहिए। बस एक तरीका जोड़ा गया है जो टोस्ट को ढूंढेगा और दिखाएगा। जिसमें डिवाइस श्रेणी में श्रेणी।

public static int differentDensityAndScreenSize(Context context) {
  int value = 20;
  String str = "";
  if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "small-ldpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "small-mdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "small-hdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "small-xhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "small-xxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "small-xxxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "small-tvdpi";
    value = 20;
    break;
   default:
    str = "small-unknown";
    value = 20;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "normal-ldpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "normal-mdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "normal-hdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "normal-xhdpi";
    value = 90;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "normal-xxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "normal-xxxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "normal-tvdpi";
    value = 96;
    break;
   default:
    str = "normal-unknown";
    value = 82;
    break;
   }
  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "large-ldpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "large-mdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "large-hdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "large-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "large-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "large-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "large-tvdpi";
    value = 125;
    break;
   default:
    str = "large-unknown";
    value = 78;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "xlarge-ldpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "xlarge-mdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "xlarge-hdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "xlarge-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "xlarge-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "xlarge-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "xlarge-tvdpi";
    value = 125;
    break;
   default:
    str = "xlarge-unknown";
    value = 125;
    break;
   }
  }
// The Toast will show the Device falls in Which Categories.
Toast.makeText(MainActivity.this, ""+str, Toast.LENGTH_SHORT).show();

  return value;
 }

http://www.androidwarriors.com/2016/01/how-to-find-different-devices-screen.html

Answer 14

यह काम करना चाहिए।

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480

Comments

डिस्प्ले के पिक्सल में आकार घनत्व नहीं है।

— जॉस्पर

यह घनत्व स्वतंत्र है पिक्सल नहीं है। और जो 320 आप देख रहे हैं वह 320dip है 320px नहीं।

— Px

Answer 15

अभी तक एक और जवाब:

/**
* @return "ldpi", "mdpi", "hdpi", "xhdpi", "xhdpi", "xxhdpi", "xxxhdpi", "tvdpi", or "unknown".
*/
public static String getDensityBucket(Resources resources) {
    switch (resources.getDisplayMetrics().densityDpi) {
        case DisplayMetrics.DENSITY_LOW:
            return "ldpi";
        case DisplayMetrics.DENSITY_MEDIUM:
            return "mdpi";
        case DisplayMetrics.DENSITY_HIGH:
            return "hdpi";
        case DisplayMetrics.DENSITY_XHIGH:
            return "xhdpi";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "xxhdpi";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "xxxhdpi";
        case DisplayMetrics.DENSITY_TV:
            return "tvdpi";
        default:
            return "unknown";
    }
}

Answer 16

डिवाइस द्वारा लोड किए गए घनत्व को प्राप्त करने का दूसरा तरीका:

valuesप्रत्येक घनत्व के लिए फ़ोल्डर बनाएँ

• मान (डिफ़ॉल्ट mdpi)
• मान-hdpi
• मान-xhdpi
• मान-xxhdpi
• मान-xxxhdpi

उनके संबंध में एक स्ट्रिंग संसाधन जोड़ें strings.xml:

<string name="screen_density">MDPI</string>    <!-- ..\res\values\strings.xml -->
<string name="screen_density">HDPI</string>    <!-- ..\res\values-hdpi\strings.xml -->
<string name="screen_density">XHDPI</string>   <!-- ..\res\values-xhdpi\strings.xml -->
<string name="screen_density">XXHDPI</string>  <!-- ..\res\values-xxhdpi\strings.xml -->
<string name="screen_density">XXXHDPI</string> <!-- ..\res\values-xxxhdpi\strings.xml -->

तो बस स्ट्रिंग संसाधन प्राप्त करें, और आपके पास अपना घनत्व है:

String screenDensity = getResources().getString(R.string.screen_density);

यदि घनत्व इससे बड़ा है XXXHDPI, तो यह डिफ़ॉल्ट होगा XXXHDPIया यदि यह उससे कम है तो HDPIयह डिफ़ॉल्ट होगाMDPI

मैंने छोड़ दिया LDPI, क्योंकि मेरे उपयोग के मामले के लिए यह आवश्यक नहीं है।

Comments

मुझे लगता है कि घनत्व प्राप्त करने का यह सही तरीका है। क्योंकि मैं getResources () का उपयोग करता हूं। getDisplayMetrics () घनत्व। यदि मैं सेटिंग में प्रदर्शन आकार बदलता हूं, तो घनत्व बदल जाएगा।

— फंतासी फेंग

Answer 17

इसे इस्तेमाल करे...

कोटलिन में

fun determineScreenDensityCode(): String {
      return when (resources.displayMetrics.densityDpi) {
         DisplayMetrics.DENSITY_LOW -> "ldpi"
         DisplayMetrics.DENSITY_MEDIUM -> "mdpi"
         DisplayMetrics.DENSITY_HIGH -> "hdpi"
         DisplayMetrics.DENSITY_XHIGH, DisplayMetrics.DENSITY_280 -> "xhdpi"
         DisplayMetrics.DENSITY_XXHIGH, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420 -> "xxhdpi"
         DisplayMetrics.DENSITY_XXXHIGH, DisplayMetrics.DENSITY_560 -> "xxxhdpi"
         else -> "Unknown code ${resources.displayMetrics.densityDpi}"
     }
}

आप कॉल कर सकते हैं println("density: ${determineScreenDensityCode()}") और आउटपुट होगाSystem.out: density: xxxhdpi

Answer 18

मैं मॉड्यूल से डीपीआई तक पहुंचने के लिए निम्नलिखित कोड का उपयोग कर रहा हूं (संदर्भ वस्तु तक पहुंच की कोई आवश्यकता नहीं):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2

Answer 19

Android में आप स्क्रीन घनत्व इस तरह प्राप्त कर सकते हैं:

public static String getScreenDensity(Context context)
{
    String density;
    switch (context.getResources().getDisplayMetrics().densityDpi)
    {
        case DisplayMetrics.DENSITY_LOW:
            density = "LDPI";
            break;
        case DisplayMetrics.DENSITY_140:
            density = "LDPI - MDPI";
            break;
        case DisplayMetrics.DENSITY_MEDIUM:
            density = "MDPI";
            break;
        case DisplayMetrics.DENSITY_180:
        case DisplayMetrics.DENSITY_200:
        case DisplayMetrics.DENSITY_220:
            density = "MDPI - HDPI";
            break;
        case DisplayMetrics.DENSITY_HIGH:
            density = "HDPI";
            break;
        case DisplayMetrics.DENSITY_260:
        case DisplayMetrics.DENSITY_280:
        case DisplayMetrics.DENSITY_300:
            density = "HDPI - XHDPI";
            break;
        case DisplayMetrics.DENSITY_XHIGH:
            density = "XHDPI";
            break;
        case DisplayMetrics.DENSITY_340:
        case DisplayMetrics.DENSITY_360:
        case DisplayMetrics.DENSITY_400:
        case DisplayMetrics.DENSITY_420:
        case DisplayMetrics.DENSITY_440:
            density = "XHDPI - XXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXHIGH:
            density = "XXHDPI";
            break;
        case DisplayMetrics.DENSITY_560:
        case DisplayMetrics.DENSITY_600:
            density = "XXHDPI - XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXXHIGH:
            density = "XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_TV:
            density = "TVDPI";
            break;
        default:
            density = "UNKNOWN";
            break;
    }

    return density;
}

और कोटलिन में इस तरह से:

fun getScreenDensity(context: Context): String {
    val density: String
    when (context.resources.displayMetrics.densityDpi) {
        DisplayMetrics.DENSITY_LOW -> density = "LDPI"
        DisplayMetrics.DENSITY_140 -> density = "LDPI - MDPI"
        DisplayMetrics.DENSITY_MEDIUM -> density = "MDPI"
        DisplayMetrics.DENSITY_180, DisplayMetrics.DENSITY_200, DisplayMetrics.DENSITY_220 -> density = "MDPI - HDPI"
        DisplayMetrics.DENSITY_HIGH -> density = "HDPI"
        DisplayMetrics.DENSITY_260, DisplayMetrics.DENSITY_280, DisplayMetrics.DENSITY_300 -> density = "HDPI - XHDPI"
        DisplayMetrics.DENSITY_XHIGH -> density = "XHDPI"
        DisplayMetrics.DENSITY_340, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420, DisplayMetrics.DENSITY_440 -> density =
            "XHDPI - XXHDPI"
        DisplayMetrics.DENSITY_XXHIGH -> density = "XXHDPI"
        DisplayMetrics.DENSITY_560, DisplayMetrics.DENSITY_600 -> density = "XXHDPI - XXXHDPI"
        DisplayMetrics.DENSITY_XXXHIGH -> density = "XXXHDPI"
        DisplayMetrics.DENSITY_TV -> density = "TVDPI"
        else -> density = "UNKNOWN"
    }

    return density
}

यदि नियमित रूप से नए घनत्व जोड़े जाते हैं, तो नियमित रूप से जाँच करें ।