Jak określić kategorię rozmiaru ekranu urządzenia (mały, normalny, duży, duży) za pomocą kodu?

308

Czy istnieje sposób na określenie kategorii rozmiaru ekranu bieżącego urządzenia, takiego jak mały, normalny, duży, duży?

Nie gęstość, ale rozmiar ekranu.

android  screen  android-screen-support 
— vieux
źródło

Odpowiedzi:

420

Możesz użyć Configuration.screenLayout maski bitowej.

Przykład:

if ((getResources().getConfiguration().screenLayout & 
    Configuration.SCREENLAYOUT_SIZE_MASK) == 
        Configuration.SCREENLAYOUT_SIZE_LARGE) {
    // on a large screen device ...

}
— Jeff Gilfelt
źródło
31
Aby uzyskać detekcję x-large, upewnij się, że używasz docelowego systemu Android-3.0 w swoim projekcie. Lub użyj wartości statycznej 4 dla x-large.
— Peterdk
5
Niektóre urządzenia mogą mieć rozmiar NIEDEFINIOWANY ekranu, więc może być przydatny również przy pomocy Configuration.SCREENLAYOUT_SIZE_UNDEFINED.
— valerybodak
Czy możesz użyć> =, aby uzyskać duże lub większe ekrany?
— Andrew S
150

Poniższy kod wyjaśnia powyższą odpowiedź, wyświetlając rozmiar ekranu jako Toast.

//Determine screen size
if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
    Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
    Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
    Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Screen size is neither large, normal or small", Toast.LENGTH_LONG).show();
}

Poniższy kod wyświetla gęstość ekranu jako Toast.

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density == DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
— Mel
źródło
Toast jest miły dla twórców.
— MinceMan
czy ktoś może potwierdzić bardzo duży?
— Nathan H
68

Odpowiedź Jeff Gilfelt jako metoda statycznego pomocnika:

private static String getSizeName(Context context) {
    int screenLayout = context.getResources().getConfiguration().screenLayout;
    screenLayout &= Configuration.SCREENLAYOUT_SIZE_MASK;

    switch (screenLayout) {
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        return "small";
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        return "normal";
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        return "large";
    case 4: // Configuration.SCREENLAYOUT_SIZE_XLARGE is API >= 9
        return "xlarge";
    default:
        return "undefined";
    }
}
— qwertzguy
źródło
12 
private String getDeviceDensity() {
    int density = mContext.getResources().getDisplayMetrics().densityDpi;
    switch (density)
    {
        case DisplayMetrics.DENSITY_MEDIUM:
            return "MDPI";
        case DisplayMetrics.DENSITY_HIGH:
            return "HDPI";
        case DisplayMetrics.DENSITY_LOW:
            return "LDPI";
        case DisplayMetrics.DENSITY_XHIGH:
            return "XHDPI";
        case DisplayMetrics.DENSITY_TV:
            return "TV";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "XXHDPI";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "XXXHDPI";
        default:
            return "Unknown";
    }
}
— Pawan Maheshwari
źródło
1
Otrzymuje to gęstość ekranu. Pytanie określa „Nie gęstość, ale rozmiar ekranu”.
— Subaru Tashiro,
11

Dziękuję za powyższe odpowiedzi, które bardzo mi pomogły :-) Ale dla tych (jak ja) zmuszonych do dalszego wspierania Androida 1.5 możemy użyć odbicie Java w kompatybilności wstecznej:

Configuration conf = getResources().getConfiguration();
int screenLayout = 1; // application default behavior
try {
    Field field = conf.getClass().getDeclaredField("screenLayout");
    screenLayout = field.getInt(conf);
} catch (Exception e) {
    // NoSuchFieldException or related stuff
}
// Configuration.SCREENLAYOUT_SIZE_MASK == 15
int screenType = screenLayout & 15;
// Configuration.SCREENLAYOUT_SIZE_SMALL == 1
// Configuration.SCREENLAYOUT_SIZE_NORMAL == 2
// Configuration.SCREENLAYOUT_SIZE_LARGE == 3
// Configuration.SCREENLAYOUT_SIZE_XLARGE == 4
if (screenType == 1) {
    ...
} else if (screenType == 2) {
    ...
} else if (screenType == 3) {
    ...
} else if (screenType == 4) {
    ...
} else { // undefined
    ...
}
— A. Masson
źródło
2
Możesz kierować reklamy na najnowszą wersję platformy i odwoływać się do stałych z Configurationklasy. Są to statyczne wartości końcowe, które zostaną wprowadzone w czasie kompilacji (to znaczy zostaną zastąpione ich rzeczywistymi wartościami), dzięki czemu kod nie zepsuje się na starszych wersjach platformy.
— Karakuri,
Fajnie, nie wiedziałem o tym ... Mówisz o Androidzie: targetSdkVersion?
— A. Masson
1
Tak, w ten sposób celowałbyś w określoną wersję. Większość ludzi (przynajmniej to widziałem) ustawia targetSdkVersionnajnowszą wersję.
— Karakuri
9

Jeśli chcesz łatwo poznać gęstość ekranu i rozmiar urządzenia z Androidem, możesz skorzystać z tej bezpłatnej aplikacji (nie wymaga pozwolenia): https://market.android.com/details?id=com.jotabout.screeninfo

— mmathieum
źródło
3
To pytanie nie dotyczy konkretnego urządzenia, dotyczy programowania wielu profili podziału (co jest ważnym procesem tworzenia oprogramowania podczas opracowywania dla platform mobilnych).
— mtmurdock
1
dobra aplikacja do poznania jest dostępna na rynku - również miło byłoby zobaczyć kod, którego używa aplikacja, aby wymyślić swoje informacje
— Stan Kurdziel
4
@StanKurdziel Kod źródłowy jest opublikowany na licencji open source MIT i jest dostępny na stronie: github.com/mportuesisf/ScreenInfo
— mmathieum
Ten link jest już
— nieaktualny
5

Chcesz sprawdzić, czy są duże ekrany i x ... wysoka gęstość? To jest zmieniony kod z wybranej odpowiedzi.

//Determine screen size
if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {     
    Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {     
    Toast.makeText(this, "Normal sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {     
    Toast.makeText(this, "Small sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {     
    Toast.makeText(this, "XLarge sized screen" , Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();
}

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density==DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XHIGH) {
    Toast.makeText(this, "DENSITY_XHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXHIGH) {
    Toast.makeText(this, "DENSITY_XXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXXHIGH) {
    Toast.makeText(this, "DENSITY_XXXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
}
— Tom McFarlin
źródło
[Gęstość] W tym przypadku musisz być aktywny. Jeśli jesteś na zewnątrz, użyj getWindowManager () ten kod WindowManager windowManager = kontekst ((WindowManager) .getSystemService (Context.WINDOW_SERVICE);
— horkavlna
3

Oto Xamarin.Android wersja odpowiedzi Toma McFarlina 

        //Determine screen size
        if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeLarge) {
            Toast.MakeText (this, "Large screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeNormal) {
            Toast.MakeText (this, "Normal screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeSmall) {
            Toast.MakeText (this, "Small screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeXlarge) {
            Toast.MakeText (this, "XLarge screen", ToastLength.Short).Show ();
        } else {
            Toast.MakeText (this, "Screen size is neither large, normal or small", ToastLength.Short).Show ();
        }
        //Determine density
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager.DefaultDisplay.GetMetrics (metrics);
        var density = metrics.DensityDpi;
        if (density == DisplayMetricsDensity.High) {
            Toast.MakeText (this, "DENSITY_HIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Medium) {
            Toast.MakeText (this, "DENSITY_MEDIUM... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Low) {
            Toast.MakeText (this, "DENSITY_LOW... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xhigh) {
            Toast.MakeText (this, "DENSITY_XHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxhigh) {
            Toast.MakeText (this, "DENSITY_XXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxxhigh) {
            Toast.MakeText (this, "DENSITY_XXXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else {
            Toast.MakeText (this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + density, ToastLength.Long).Show ();
        }
— ellechino
źródło
2
Proszę nie tylko zrzucić trochę kodu, ale wyjaśnić, co zrobiłeś i jak to pomaga
— David Medenjak,
2

Wypróbuj tę funkcję isLayoutSizeAtLeast (int screenSize)

Aby sprawdzić mały ekran, przynajmniej 320x426 dp i powyżej getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_SMALL);

Aby sprawdzić normalny ekran, przynajmniej 320x470 dp i powyżej getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_NORMAL);

Aby sprawdzić duży ekran, przynajmniej 480 x 640 dp i powyżej getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_LARGE);

Aby sprawdzić bardzo duży ekran, przynajmniej 720x960 dp i powyżej getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_XLARGE);

— Devendra Vaja
źródło
Miły! Ta metoda jest dostępna już od poziomu API 11!
— Enselic,
2

W 2018 roku, jeśli potrzebujesz odpowiedzi Jeffa w Kotlinie, oto ona:

  private fun determineScreenSize(): String {
    // Thanks to https://stackoverflow.com/a/5016350/2563009.
    val screenLayout = resources.configuration.screenLayout
    return when {
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_XLARGE -> "Xlarge"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_UNDEFINED -> "Undefined"
      else -> error("Unknown screenLayout: $screenLayout")
    }
  }
— Thuy Trinh
źródło
1

Czy nie możesz tego zrobić za pomocą zasobu ciągów i znaków wyliczających? Możesz zdefiniować zasób łańcucha, który miał nazwę rozmiaru ekranu, taki jak MAŁY, ŚREDNI lub DUŻY. Następnie można użyć wartości zasobu ciągów, aby utworzyć wystąpienie wyliczenia.

  1. Zdefiniuj Enum w swoim kodzie dla różnych rozmiarów ekranu, na których Ci zależy. 

    public Enum ScreenSize {
    SMALL,
    MEDIUM,
    LARGE,;
}

  2. Zdefiniuj zasób łańcucha, np. Rozmiar ekranu, którego wartość będzie MAŁA, ŚREDNIA lub DUŻA. 

    <string name="screensize">MEDIUM</string>
  3. Umieść kopię screensizew łańcuchu znaków w każdym interesującym cię wymiarze.
    Na przykład <string name="screensize">MEDIUM</string>przejdzie do wartości-sw600dp / strings.xml i wartości-medium / strings.xml i <string name="screensize">LARGE</string>przejdzie do sw720dp / strings.xml i wartości-large / strings.xml.
  4. Pisz w kodzie
    ScreenSize size = ScreenSize.valueOf(getReources().getString(R.string.screensize);
— Prof Mo
źródło
To było obiecujące ... Jednak testowałem z 3 urządzeniami, a tablet wciąż MAŁY, gdy oczekuję DUŻYCH. Moje pliki string.xml są zdefiniowane wewnątrz wartości-h1024dp, wartości-h700dp i wartości-h200dp z odpowiednim <string name = "screenize"> xxxxxx </entry>
— A. Masson
1

Skopiuj i wklej ten kod do swojego, Activitya gdy zostanie wykonany, będzie Toastto kategoria rozmiaru ekranu urządzenia.

int screenSize = getResources().getConfiguration().screenLayout &
        Configuration.SCREENLAYOUT_SIZE_MASK;

String toastMsg;
switch(screenSize) {
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        toastMsg = "Large screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        toastMsg = "Normal screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        toastMsg = "Small screen";
        break;
    default:
        toastMsg = "Screen size is neither large, normal or small";
}
Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();
— Alireza Ghanbarinia
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.