mendapatkan kepadatan layar secara terprogram di android?

516

Bagaimana cara mendapatkan kerapatan layar secara terprogram di android?

Maksud saya: Bagaimana menemukan dpi layar perangkat saat ini?

android  dpi  screen-density 
— Praveen
sumber
9
Banyak jawaban merujuk getDisplayMetrics().xdpi, yang seharusnya mengembalikan dpi perangkat yang sebenarnya. Harap perhatikan bahwa nilai ini tidak ditetapkan secara konsisten di seluruh perangkat oleh pabrikan, jadi Anda tidak dapat menggunakannya . Sedih tetapi benar: informasi tentang dpi nyata tidak tersedia . Sumber: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
— sulai
2
getResources().getDisplayMetrics().xdpidan getResources().getDisplayMetrics().ydpiakan memberi Anda kepadatan horisontal dan vertikal yang sebenarnya , yang dalam banyak kasus berbeda.
— Ωmega

Jawaban:

526

Anda bisa mendapatkan info tentang tampilan dari struct DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Meskipun Android tidak menggunakan pemetaan piksel langsung, ia menggunakan beberapa nilai Density Independent Pixel yang dikuantisasi kemudian menskala ke ukuran layar aktual. Jadi metrics.densityDpiproperti akan menjadi salah satu DENSITY_xxxkonstanta ( 120, 160, 213, 240, 320, 480atau 640dpi).

Jika Anda membutuhkan kerapatan piksel lcd yang sebenarnya (mungkin untuk aplikasi OpenGL), Anda bisa mendapatkannya dari metrics.xdpidan metrics.ydpiproperti untuk kerapatan horizontal dan vertikal.

Jika Anda menargetkan Tingkat API lebih awal dari 4. metrics.densityProperti adalah faktor penskalaan titik mengambang dari kepadatan referensi (160dpi). Nilai yang sama sekarang disediakan oleh metrics.densityDpidapat dihitung

int densityDpi = (int)(metrics.density * 160f);
— Joshperry
sumber
42
Memang posting ini berasal dari lebih dari dua tahun yang lalu, tetapi ini adalah hal pertama yang muncul di Google untuk pencarian ini, jadi bagi siapa saja yang menemukan ini, Anda tidak perlu lagi mengalikan 160.
— roboguy12
5
Tidak lagi sejak versi yang mana?
— TacB0sS
Saya telah memperbarui jawaban untuk mencocokkan revisi API terbaru yang mungkin digunakan orang.
— joshperry
6
Catatan: Anda mungkin menginginkan API yang lebih baru ini sebagai gantinya: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); Ini secara resmi ditambahkan di API 17, tetapi saya terkejut menemukan bahwa itu berfungsi dengan benar bahkan pada perangkat 4.0 yang saya coba.
— benkc
2
ada juga getResources (). getDisplayMetrics (). densityDpi
— amorenew
367

Ini juga berfungsi:

 getResources().getDisplayMetrics().density;

Ini akan memberi Anda:

0,75 - ldpi

1.0 - mdpi

1,5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

masukkan deskripsi gambar di sini

ref: density

masukkan deskripsi gambar di sini

ref 2

— Blundell
sumber
10
+1 Ini berfungsi saat Anda tidak memiliki akses langsung ke WindowManager(mis. Di dalam Loader). Cukup kalikan dengan 160
— Michał K
2
API Level 16 menambahkan xxdpi, yang diterjemahkan di sini menjadi 3.0.
— QED
3
ini akan memberi 1,3312501 untuk tvdpi. Untuk info lebih lanjut tvdpilihat di sini
— Dori
2
Nexus 7 melaporkan 1.3, mengapa braket itu harus masuk?
— Neil
1
@selbie, ponsel Anda mungkin menarik dan menskala sumber daya berkualitas tinggi karena ponsel Anda melaporkan setengah jalan antara dua kepadatan yang ditentukan.
— 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;
}

Ini akan bekerja pada API level 4 dan lebih tinggi.

— Mitul Nakum
sumber
Bagaimana Anda menyerahkan perangkat seperti Nexus 7 yang melaporkan densitas Dpi sebagai 213?
— Neil
miliki jika-kalau tangan memeriksa antara nilai kepadatan seperti, jika (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
— Mitul Nakum
1
ATAU jika (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} jika lain (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
— Mitul Nakum
1
Neil, 213 disebut TV DPI, ada kepadatan metrik tampilan bernama untuk DENSITY_TV itu.
— Andrew S
63

Jawaban Blundell sebagai metode pembantu statis:

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
sumber
bagaimana dengan kepadatan tvdpi. Saya kira itu 1,33
— Anoop
@AnoopssGolden Ini tidak benar-benar standar, jadi Anda dapat menambahkannya jika Anda mau, tapi saya rasa jawabannya tidak harus menyertakannya. Dari dokumen android: "Ini tidak dianggap sebagai grup kepadatan" primer ". Ini sebagian besar ditujukan untuk televisi dan sebagian besar aplikasi tidak memerlukannya".
— qwertzguy
Tapi perangkat nexus 7 milik grup kepadatan TVDPI.
— Anoop
1
Saya tahu ini agak lama tetapi hanya untuk menambahkan; MDPI mungkin berfungsi untuk sebagian besar hal pada Nexus 7 tetapi saat saya coba sekarang, gambar turun karena MDPI tidak cukup besar. Saya harus mendefinisikan TVDPI dan kemudian meminta ukuran gambar yang lebih besar dari server saya. Ini mungkin tidak banyak digunakan tetapi itu tidak berarti MDPI akan mengambil semuanya.
— RED_
3
Hai @Andrew S, menggunakan elses tidak mengubah apa pun untuk efisiensi kode karena setiap jika kembali segera. Menghapus kawat gigi adalah masalah gaya saja dan IMHO membuatnya lebih rentan kesalahan saat mempertahankan kode.
— qwertzguy
45

Coba ini:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
— Wizist
sumber
5
Saya suka ini jauh lebih baik karena bergantung pada konteks daripada aktivitas.
— greg7gkb
Setuju, saya bisa menggunakan ini dari yang Viewlebih mudah (di situlah saya membutuhkannya!)
— Andrew Wyld
37

Untuk mendapatkan 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
sumber
4
dm.densityDpi mengembalikan DENSITY_LOW atau DENSITY_MEDIUM atau DENSITY_HIGH. Bagaimana dengan xhdpi? Apakah ada DENSITY_XHIGH atau lebih?
— Eugene Chumak
— gak
34

Berikut adalah konstanta densitas, sumber :

masukkan deskripsi gambar di sini

Ada, selain kepadatan standar, 5 yang Menengah. Dengan mempertimbangkan fakta ini, kode berikut akan menjadi contoh kerja yang lengkap:

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 
}

Atau, Anda dapat menemukan konstanta kerapatan menggunakan 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
sumber
29

Jawaban berikut adalah peningkatan kecil berdasarkan jawaban 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
}
— San
sumber
1
Kode ini bisa dilakukan dengan beberapa elses, dan ampersand dan ketentuan setelah itu berlebihan.
— Andrew S
1
@ Andrew, terima kasih atas koreksinya. Saya telah mengedit jawaban sesuai dengan itu.
— San
2
@San Anda tidak memerlukan && dalam kondisi apa pun, selama Anda secara konsisten memeriksa> = yang lain jika akan mengakhiri kondisi pertama yang benar.
— dbenson
3
Ini tidak mengembalikan hasil yang benar bagi saya dengan Nexus 5X saya (perangkat google default btw). Kerapatan perangkat adalah xxhdpi, dan kerapatan ganda yang dikembalikan sekitar 2,6.
— Tobliug
20

Sebenarnya jika Anda ingin memiliki tampilan nyata dpi , jawabannya ada di antara keduanya jika Anda meminta metrik tampilan:

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

densityDpi * 160 akan memberi Anda nilai / saran kepadatan mana yang harus Anda gunakan

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

seperti yang ditentukan dalam posting sebelumnya

tetapi dm.xdpitidak akan selalu memberi Anda dpi NYATA dari tampilan yang diberikan: Contoh:

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

jadi mungkin nyata dpi tampilan harus Density * xdpi .. tapi saya tidak yakin apakah ini cara yang benar untuk dilakukan!

— Marek Halmo
sumber
1
Menggunakan Density * xdpi bekerja dengan sangat baik sejauh ini di semua aplikasi saya di google play selama 6 bulan terakhir
— Marek Halmo
Mengalikan kepadatan * xdpi tidak logis, yang lebih jelas sekarang bahwa ada lebih banyak perangkat kepadatan yang lebih tinggi - baik Density dan xdpi meningkat, jadi mengalikannya akan menghitung peningkatan dua kali lipat. Saya akan mengatakan Samsung ace 2 adalah kesalahan oleh vendor. Spesifikasi Android adalah bahwa xdpi dan ydpi adalah kepadatan piksel sebenarnya - jangan dikalikan dengan apa pun.
— ToolmakerSteve
17

Ini akan membantu aktivitas Anda ...

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
— prabhu
sumber
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
sumber
11

Jika Anda ingin mengambil kepadatan dari Layanan berfungsi seperti ini:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
— Nama tampilan
sumber
Yang ini membantu saya ketika saya tidak punya windowManager
— silentsudo
8

Anda Harus Coba Ini. Baru Ditambahkan Metode yang akan menemukan dan Tampilkan Roti Panggang. Bahwa dalam Kategori Yang Perangkat Jatuh.

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
sumber
7

Ini seharusnya bekerja.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
— Robby Pond
sumber
4
Ukuran dalam piksel tampilan bukan kepadatan.
— joshperry
1
Ini adalah piksel yang bebas kerapatan, bukan piksel. Dan 320 yang Anda lihat adalah 320dip bukan 320px. Perhitungan px berbeda lihat stackoverflow.com/questions/6840904/…
— Lukap
7

Namun jawaban lain:

/**
* @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
sumber
3

Cara lain untuk mendapatkan kepadatan yang dimuat oleh perangkat:

Buat valuesfolder untuk setiap kepadatan

  • nilai (mdpi default)
  • nilai-hdpi
  • nilai-xhdpi
  • nilai-xxhdpi
  • nilai-xxxhdpi

Tambahkan sumber string di masing-masing 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 -->

Maka cukup dapatkan sumber daya string, dan Anda memiliki kepadatan:

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

Jika kerapatan lebih besar dari XXXHDPI, itu akan default ke XXXHDPIatau jika lebih rendah daripada HDPIitu akan default untukMDPI

Nilai-nilai R.strings.screen_density

Saya ketinggalan LDPI, karena untuk use case saya tidak perlu.

— Pierre
sumber
Saya pikir ini adalah cara yang tepat untuk mendapatkan kepadatan. Karena saya menggunakan kerapatan getResources (). GetDisplayMetrics ()., Kerapatan akan berubah jika saya mengubah ukuran tampilan dalam pengaturan.
— Fantasy Fang
1

Coba ini...

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

Anda dapat menelepon oleh println("density: ${determineScreenDensityCode()}") dan hasilnya akanSystem.out: density: xxxhdpi

— Silambarasan Poonguti
sumber
0

Saya menggunakan kode berikut untuk mengakses DPI dari modul (tidak perlu memiliki akses ke objek konteks):

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

Di Android Anda bisa mendapatkan kerapatan layar seperti ini:

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

Dan di Kotlin seperti ini:

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
}

Pastikan untuk memeriksa secara teratur jika kepadatan baru ditambahkan .

— Wirling
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.