Erhalten Sie die Bildschirmdichte programmgesteuert in Android?

516

Wie bekomme ich die Bildschirmdichte programmgesteuert in Android?

Ich meine: Wie finde ich die Bildschirm-dpi des aktuellen Geräts?

android  dpi  screen-density 
— Praveen
quelle
9
Es beziehen sich viele Antworten getDisplayMetrics().xdpi, die die tatsächliche dpi des Geräts zurückgeben sollen. Bitte beachten Sie, dass dieser Wert von den Herstellern auf allen Geräten nicht konsistent eingestellt wird , sodass Sie sie einfach nicht verwenden können . Traurig aber wahr: Die Informationen über echte dpi sind nicht verfügbar . Quelle: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
— Sulai
2
getResources().getDisplayMetrics().xdpiund getResources().getDisplayMetrics().ydpigibt Ihnen tatsächliche horizontale und vertikale Dichten , die in den meisten Fällen unterschiedlich sind.
— Ωmega

Antworten:

526

Informationen zur Anzeige erhalten Sie in der DisplayMetrics- Struktur:

DisplayMetrics metrics = getResources().getDisplayMetrics();

Obwohl Android keine direkte Pixelzuordnung verwendet, verwendet es eine Handvoll quantisierter dichteunabhängiger Pixelwerte und skaliert dann auf die tatsächliche Bildschirmgröße. So ist die metrics.densityDpiEigenschaft eines der seine DENSITY_xxxKonstanten ( 120, 160, 213, 240, 320, 480oder 640dpi).

Wenn Sie die tatsächliche LCD-Pixeldichte benötigen (möglicherweise für eine OpenGL-App), können Sie diese über die Eigenschaften metrics.xdpiund metrics.ydpifür die horizontale bzw. vertikale Dichte abrufen.

Wenn Sie auf API-Ebenen vor 4 abzielen. Die metrics.densityEigenschaft ist ein Gleitkomma-Skalierungsfaktor aus der Referenzdichte (160 dpi). Der gleiche Wert, der jetzt von bereitgestellt wird, metrics.densityDpikann berechnet werden

int densityDpi = (int)(metrics.density * 160f);
— Joshperry
quelle
42
Zugegeben, dieser Beitrag stammt von vor über zwei Jahren, aber dies ist das erste, was bei Google für diese Suche auftaucht. Für jeden, der dies findet, müssen Sie nicht mehr mit 160 multiplizieren.
— roboguy12
5
Nicht mehr seit welcher Version?
— TacB0sS
Ich habe die Antwort aktualisiert, um sie an die neuesten API-Revisionen anzupassen, die möglicherweise verwendet werden.
— Joshperry
6
Hinweis: Möglicherweise möchten Sie stattdessen diese neuere API: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); Diese wurde offiziell in API 17 hinzugefügt, aber ich war überrascht, dass sie auch auf einem 4.0-Gerät, das ich ausprobiert habe, ordnungsgemäß funktioniert hat.
— Benkc
2
Es gibt auch getResources (). getDisplayMetrics (). DichteDpi
— amorenew
367

Dies funktioniert auch:

 getResources().getDisplayMetrics().density;

Dies wird Ihnen geben:

0,75 - ldpi

1,0 - mdpi

1,5 - hdpi

2,0 - xhdpi

3,0 - xxhdpi

4.0 - xxxhdpi

Geben Sie hier die Bildbeschreibung ein

ref: Dichte

Geben Sie hier die Bildbeschreibung ein

Ref 2

— Blundell
quelle
10
+1 Dies funktioniert, wenn Sie keinen direkten Zugriff haben WindowManager(z. B. innerhalb eines Loaders). Multiplizieren Sie es einfach mit 160
— Michał K
2
API Level 16 fügte xxdpi hinzu, was hier in 3.0 übersetzt wird.
— QED
3
Dies ergibt 1,3312501 für tvdpi. Weitere Informationen finden tvdpiSie hier
— Dori
2
Nexus 7 meldet 1.3, warum sollte das in die Klammer gehen?
— Neil
1
@selbie, Ihr Telefon zieht und skaliert wahrscheinlich die Ressourcen mit höherer Qualität, da Ihr Telefon auf halbem Weg zwischen zwei definierten Dichten meldet.
— Sakiboy
145 
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;
}

Dies funktioniert auf API-Ebene 4 und höher.

— Mitul Nakum
quelle
Wie würden Sie Geräte wie Nexus 7 übergeben, die DensityDpi als 213 melden?
— Neil
Lassen Sie die if-else-Hand zwischen den Dichtewerten prüfen, z. B. if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW &&metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
— Mitul Nakum
1
ODER if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} else if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
— Mitul Nakum
1
Neil, 213 heißt TV DPI, für dieses DENSITY_TV gibt es eine benannte Anzeigemetrikdichte.
— Andrew S
63

Blundells Antwort als statische Hilfsmethode:

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";
}
— qwertzguy
quelle
Was ist mit der TVDPI-Dichte? Ich denke, es ist 1.33
— Anoop
@AnoopssGolden Es ist nicht wirklich Standard, also kannst du es hinzufügen, wenn du willst, aber ich denke nicht, dass die Antwort es enthalten sollte. Aus den Android-Dokumenten: "Dies wird nicht als" primäre "Dichtegruppe angesehen. Es ist hauptsächlich für Fernseher gedacht und die meisten Apps sollten es nicht benötigen."
— qwertzguy
Das Nexus 7-Gerät gehört jedoch zur tvdpi-Dichtegruppe.
— Anoop
1
Ich weiß, dass dies ein bisschen alt ist, aber nur um hinzuzufügen; MDPI funktioniert möglicherweise für die meisten Dinge auf einem Nexus 7, aber während ich es jetzt versuche, sind Bilder, die als MDPI herunterkommen, nicht groß genug. Ich muss TVDPI definieren und dann von meinem Server eine größere Bildgröße anfordern. Es wird möglicherweise nicht viel verwendet, aber das bedeutet nicht, dass MDPI alles aufnimmt.
— RED_
3
Hey @Andrew S, die Verwendung von elses ändert nichts an der Effizienz des Codes, da jedes if sofort zurückkehrt. Das Entfernen von geschweiften Klammern ist nur eine Frage des Stils, und IMHO macht es fehleranfälliger, wenn der Code beibehalten wird.
— qwertzguy
45

Versuche dies:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
— Wizist
quelle
5
Ich mag das viel besser, da es eher auf dem Kontext als auf der Aktivität beruht.
— Greg7gkb
Einverstanden, ich kann dies Viewviel einfacher verwenden (wo ich es brauche!)
— Andrew Wyld
37

So erhalten Sie dpi:

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;
— Jere.Jones
quelle
4
dm.densityDpi gibt entweder DENSITY_LOW oder DENSITY_MEDIUM oder DENSITY_HIGH zurück. Was ist mit xhdpi? Gibt es DENSITY_XHIGH oder so?
— Eugene Chumak
— caw
34

Hier sind die Dichtekonstanten, Quelle :

Geben Sie hier die Bildbeschreibung ein

Zusätzlich zu den Standarddichten gibt es 5 Zwischendichten. Unter Berücksichtigung dieser Tatsache ist der folgende Code ein vollständiges Arbeitsbeispiel:

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 
}

Alternativ können Sie Dichtekonstanten finden mit 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;
}
— Ayaz Alifov
quelle
29

Die folgende Antwort ist eine kleine Verbesserung, die auf der Antwort von qwertzguy basiert. 

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
}
— San
quelle
1
Dieser Code könnte einige andere vertragen, und die kaufmännischen Und-Zeichen und Bedingungen danach sind redundant.
— Andrew S
1
@ Andrew, danke für die Korrektur. Ich habe die Antwort entsprechend bearbeitet.
— San
2
@San Sie benötigen das && in keiner dieser Bedingungen, solange Sie konsequent nach> = das else if gesucht haben, das für die erste Bedingung beendet wird, die wahr ist.
— Dbenson
3
Dies liefert mit meinem Nexus 5X (übrigens ein Standard-Google-Gerät) kein korrektes Ergebnis für mich. Die Gerätedichte beträgt xxhdpi und die zurückgegebene doppelte Dichte liegt bei etwa 2,6.
— Tobliug
20

Wenn Sie die tatsächliche Anzeige-dpi haben möchten, liegt die Antwort tatsächlich irgendwo dazwischen, wenn Sie nach Anzeigemetriken fragen:

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

DichteDpi * 160 gibt Ihnen die Werte / Vorschläge, welche Dichte Sie verwenden sollten

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

wie in früheren Beiträgen angegeben

Sie erhalten jedoch dm.xdpinicht immer die ECHTE dpi der angegebenen Anzeige: Beispiel:

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

Vielleicht sollte die tatsächliche Auflösung des Displays Density * xdpi sein. Ich bin mir jedoch nicht sicher, ob dies der richtige Weg ist.

— Marek Halmo
quelle
1
Die Verwendung von Density * xdpi funktioniert in den letzten 6 Monaten auf allen meinen Apps auf Google Play perfekt
— Marek Halmo
Die Multiplikation der Dichte * xdpi ist nicht logisch, was jetzt klarer ist, da es Geräte mit höherer Dichte gibt - sowohl die Dichte als auch die xdpi-Zunahme. Eine Multiplikation würde also die Zunahme doppelt zählen. Ich würde sagen, Samsung Ace 2 war ein Fehler des Anbieters. Die Android-Spezifikation besagt, dass xdpi und ydpi die wahren Pixeldichten sind - multiplizieren Sie nicht mit irgendetwas.
— ToolmakerSteve
17

Dies sollte bei Ihrer Aktivität helfen ...

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

}

AUSGABE : 

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
— Prabhu
quelle
13 
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;
}
— Felipe
quelle
11

Wenn Sie die Dichte von einem Dienst abrufen möchten, funktioniert dies folgendermaßen:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
— Anzeigename
quelle
Dieser half mir, als ich keinen windowManager hatte
— silentsudo
8

Sie sollten dies versuchen. Gerade eine Methode hinzugefügt, die den Toast findet und anzeigt. Das, in welche Kategorie das Gerät fällt.

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

— Avinash Verma
quelle
7

Das sollte funktionieren.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
— Robby Pond
quelle
4
Die Größe des Displays in Pixel entspricht nicht der Dichte.
— Joshperry
1
Dies sind dichteunabhängige Pixel, nicht die Pixel. Und das 320, das Sie sehen, ist 320dip, nicht 320px. Die Berechnung von px ist anders siehe diese stackoverflow.com/questions/6840904/…
— Lukap
7

Noch eine Antwort:

/**
* @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";
    }
}
— Jared Rummler
quelle
3

Eine andere Möglichkeit, die vom Gerät geladene Dichte zu ermitteln:

Erstellen Sie valuesOrdner für jede Dichte

  • Werte (Standard-MDPI)
  • Werte-hdpi
  • Werte-xhdpi
  • Werte-xxhdpi
  • Werte-xxxhdpi

Fügen Sie eine Zeichenfolgenressource in ihre jeweiligen hinzu 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 -->

Dann holen Sie sich einfach die String-Ressource und Sie haben Ihre Dichte:

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

Wenn die Dichte größer als ist XXXHDPI, wird standardmäßig XXXHDPIoder niedriger als HDPIstandardmäßigMDPI

R.strings.screen_density Werte

Ich habe weggelassen LDPI, weil es für meinen Anwendungsfall nicht notwendig ist.

— Pierre
quelle
Ich denke, dies ist der richtige Weg, um die Dichte zu erhalten. Da ich die Dichte getResources (). GetDisplayMetrics (). Verwende, würde sich die Dichte ändern, wenn ich die Anzeigegröße in der Einstellung ändere.
— Fantasy Fang
1

Versuche dies...

In Kotlin

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

Sie können anrufen println("density: ${determineScreenDensityCode()}") und die Ausgabe wird seinSystem.out: density: xxxhdpi

— Silambarasan Poonguti
quelle
0

Ich verwende folgenden Code, um von Modulen aus auf DPI zuzugreifen (kein Zugriff auf ein Kontextobjekt erforderlich):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2
— Jan Málek
quelle
0

In Android können Sie die Bildschirmdichte wie folgt abrufen:

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

Und in Kotlin so:

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
}

Überprüfen Sie regelmäßig , ob neue Dichten hinzugefügt werden .

— Verkabelung
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.