Holen Sie sich Bildschirmbreite und -höhe in Android

477

Wie kann ich die Bildschirmbreite und -höhe ermitteln und diesen Wert verwenden in:

@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
    Log.e(TAG, "onMeasure" + widthSpecId);
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
        game.findViewById(R.id.flag).getHeight());
}
rebel_UA
quelle

Antworten:

1000

Mit diesem Code können Sie die Breite und Höhe der Laufzeitanzeige abrufen:

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

In einer Ansicht müssen Sie Folgendes tun:

((Activity) getContext()).getWindowManager()
                         .getDefaultDisplay()
                         .getMetrics(displayMetrics);

In einigen Szenarien, in denen Geräte über eine Navigationsleiste verfügen, müssen Sie zur Laufzeit Folgendes überprüfen:

public boolean showNavigationBar(Resources resources)
{
    int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
    return id > 0 && resources.getBoolean(id);
}

Wenn das Gerät über eine Navigationsleiste verfügt, zählen Sie die Höhe:

private int getNavigationBarHeight() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        int usableHeight = metrics.heightPixels;
        getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
        int realHeight = metrics.heightPixels;
        if (realHeight > usableHeight)
            return realHeight - usableHeight;
        else
            return 0;
    }
    return 0;
}

Die endgültige Höhe des Geräts beträgt also:

int height = displayMetrics.heightPixels + getNavigationBarHeight();
Parag Chauhan
quelle
33
Werden Breite und Höhe vertauscht, wenn das Gerät gedreht wird?
Madeyedexter
14
@ Madeyedexter ja das wird es.
Parag Chauhan
1
Sie können jedoch nicht mehr davon ausgehen, dass Sie auf der Standardanzeige ausgeführt werden.
Samstag,
1
oder verwenden Sie einfach - getResources (). getDisplayMetrics (). heightPixels / getResources (). getDisplayMetrics (). widthPixels
Alex
1
@EpicPandaForce Eigentlich dachte ich an Android Oreo, mit dem eine Aktivität auf einem anderen Display gestartet werden kann. Siehe: developer.android.com/reference/android/app/…
Satur9nine
275

Es gibt eine sehr einfache Antwort und ohne Pass-Kontext

public static int getScreenWidth() {
    return Resources.getSystem().getDisplayMetrics().widthPixels;
}

public static int getScreenHeight() {
    return Resources.getSystem().getDisplayMetrics().heightPixels;
}

Hinweis: Wenn Sie möchten, dass die Höhe die Navigationsleiste enthält, verwenden Sie die folgende Methode

WindowManager windowManager =
        (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
    final Display display = windowManager.getDefaultDisplay();
    Point outPoint = new Point();
    if (Build.VERSION.SDK_INT >= 19) {
        // include navigation bar
        display.getRealSize(outPoint);
    } else {
        // exclude navigation bar
        display.getSize(outPoint);
    }
    if (outPoint.y > outPoint.x) {
        mRealSizeHeight = outPoint.y;
        mRealSizeWidth = outPoint.x;
    } else {
        mRealSizeHeight = outPoint.x;
        mRealSizeWidth = outPoint.y;
    }
Weigan
quelle
3
Wie erhalte ich die gesamte Bildschirmhöhe? Diese Version von getScreenHeight schließt alle Balken aus.
Jaydev
1
Dies funktioniert in den meisten Fällen, kann jedoch nicht die tatsächliche Bildschirmhöhe ermitteln, wenn die Navigationsleiste sichtbar ist. Die Höhe schließt die Höhe des Balkens aus.
L. Swifter
Dies führte zu ungewöhnlichen Ergebnissen für mich im Querformat
Carson Holzheimer
1
Dies wird Probleme auf Bildschirmen mit mehreren Displays (Faltbare, Chrome OS-Laptops) verursachen
EpicPandaForce
Die Höhe der Navigationsleiste ist nicht in Android 4.4
mstoic
45

Nur um die Antwort von parag und SpK zu aktualisieren, um sie an die aktuelle SDK-Abwärtskompatibilität von veralteten Methoden anzupassen:

int Measuredwidth = 0;  
int Measuredheight = 0;  
Point size = new Point();
WindowManager w = getWindowManager();

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)    {
    w.getDefaultDisplay().getSize(size);
    Measuredwidth = size.x;
    Measuredheight = size.y; 
}else{
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
}
digiphd
quelle
7
@digiphd würde Parangs Code nicht auf allen API-Versionen funktionieren? Alle Methoden wurden vor API Level 8 eingeführt und ich fand sie auf der Android Dev Site nicht veraltet.
Sufian
@ Sufian Ich hatte Probleme, Rückgabewerte ungleich 0 von der getSizeImplementierung auf einem Samsung Galaxy Mini (API 10) zu erhalten, aber die veralteten Methoden in dieser Antwort geben korrekt zurück. Dies ist also nützlich für ältere Versionen von Android.
Damien Diehl
@ Sufian können wir eine neue Dimension für Bildschirmbreite und -höhe festlegen?
Srishti Roy
Dies wird jetzt abgeschrieben :(
Cegprakash
24

Warum nicht

DisplayMetrics displaymetrics = getResources (). GetDisplayMetrics ();

dann benutze

displayMetrics.widthPixels (heightPixels)

wangqi060934
quelle
13

Versuchen Sie den folgenden Code: -

1.

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

2.

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

oder

int width = getWindowManager().getDefaultDisplay().getWidth(); 
int height = getWindowManager().getDefaultDisplay().getHeight();

3.

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

metrics.heightPixels;
metrics.widthPixels;
Duggu
quelle
3
Glaubst
Bedeutet, dass
Ist es möglich, die "natürliche" Auflösung des Geräts zu erhalten? Das heißt, unabhängig davon, ob Sie den Bildschirm drehen, erhalten Sie dieselben Werte für Breite und Höhe. Wenn es sich um ein Tablet handelt, das horizontal verwendet werden soll, wird die Breite als große anstelle der Höhe zurückgegeben.
Android-Entwickler
12

Es ist sehr einfach, in Android zu bekommen:

int width  = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;
Ness Tyagi
quelle
Dies gibt 0 auf einem Emulator zurück
l3ob
7

Für Kotlin-Benutzer

fun Activity.displayMetrics(): DisplayMetrics {
   val displayMetrics = DisplayMetrics()
   windowManager.defaultDisplay.getMetrics(displayMetrics)
   return displayMetrics
}

Und in Aktivität können Sie es wie verwenden

     resources.displayMetrics.let { displayMetrics ->
        val height = displayMetrics.heightPixels
        val width = displayMetrics.widthPixels
    }

Oder in Fragment

    activity?.displayMetrics()?.run {
        val height = heightPixels
        val width = widthPixels
    }
Ali Mohammadi
quelle
6
DisplayMetrics dimension = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dimension);
        int width = dimension.widthPixels;
        int height = dimension.heightPixels;
Cristiana Chavez
quelle
6
DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;
Shubham
quelle
6

Ermitteln Sie den Wert für Bildschirmbreite und -höhe.

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
width = size.x;
height = size.y;
Anil Singhania
quelle
4
Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();
Rahul Yadav
quelle
Veraltet, verwenden Sie DisplayMetrics ()
Deyanm
4
public class DisplayInfo {
    int screen_height=0, screen_width=0;
    WindowManager wm;
    DisplayMetrics displaymetrics;

    DisplayInfo(Context context) {
        getdisplayheightWidth(context);
    }

    void getdisplayheightWidth(Context context) {
        wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        displaymetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displaymetrics);
        screen_height = displaymetrics.heightPixels;
        screen_width = displaymetrics.widthPixels;
    }

    public int getScreen_height() {
        return screen_height;
    }

    public int getScreen_width() {
        return screen_width;
    }
}
Habibur Rahman Ovie
quelle
4

Keine der Antworten hier funktioniert korrekt für mehrere Chrome OS-Displays oder zukünftige Foldables.

Verwenden Sie bei der Suche nach der aktuellen Konfiguration immer die Konfiguration aus Ihrer aktuellen Aktivität in getResources().getConfiguration(). Verwenden Sie nicht die Konfiguration aus Ihrer Hintergrundaktivität oder die aus der Systemressource. Die Hintergrundaktivität hat keine Größe, und die Systemkonfiguration enthält möglicherweise mehrere Fenster mit widersprüchlichen Größen und Ausrichtungen , sodass keine verwendbaren Daten extrahiert werden können.

Die Antwort lautet also

val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp
EpicPandaForce
quelle
3

Die hier gezeigten Methoden sind veraltet / veraltet, aber dies funktioniert immer noch. API 13 anfordern

Hör zu

Display disp= getWindowManager().getDefaultDisplay();
Point dimensions = new Point();
disp.getSize(size);
int width = size.x;
int height = size.y;
Hemant Shori
quelle
3

Vollständiger Weg, um die wahre Auflösung zurückzugeben:

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

Und da sich dies bei unterschiedlicher Ausrichtung ändern kann, gibt es hier eine Lösung (in Kotlin), um es unabhängig von der Ausrichtung richtig zu machen:

/**
 * returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
 * The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
    //based on : http://stackoverflow.com/a/9888357/878126
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val config = context.resources.configuration
    val rotation = windowManager.defaultDisplay.rotation
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
        Configuration.ORIENTATION_LANDSCAPE
    else
        Configuration.ORIENTATION_PORTRAIT
}

/**
 * returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
    val screenNaturalOrientation = getScreenNaturalOrientation(context)
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val point = Point()
    wm.defaultDisplay.getRealSize(point)
    val currentOrientation = context.resources.configuration.orientation
    if (currentOrientation == screenNaturalOrientation)
        return point
    else return Point(point.y, point.x)
}
Android-Entwickler
quelle
1

Verwenden Sie einfach die folgende Funktion, die Breite und Höhe der Bildschirmgröße als Array von Ganzzahlen zurückgibt

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

Fügen Sie auf Ihrer onCreate-Funktion oder Schaltfläche den folgenden Code hinzu, um die Bildschirmgrößen wie unten gezeigt auszugeben

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);
Daniel Nyamasyo
quelle
1

Versuchen Sie diesen Code für Kotlin

 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y
Najib Ahmed Puthawala
quelle
1

Ich verwende den folgenden Code, um die Bildschirmabmessungen zu erhalten

getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()
Harsha
quelle
1

Ich habe die Antwort für die Kotlin-Sprache aktualisiert!

Für Kotlin: Sie sollten Window Manager aufrufen und Metriken abrufen. Nach diesem einfachen Weg.

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

Wie können wir es effektiv in unabhängiger Weise mit der Kotlin-Sprache nutzen?

Hier habe ich eine Methode in der allgemeinen Kotlin-Klasse erstellt. Sie können es in allen Aktivitäten verwenden.

private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"

private fun getDeviceSizes(activity:Activity, whichSize:String):Int{

    val displayMetrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(displayMetrics)

    return when (whichSize){
        T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
        T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
        else -> 0 // Error
    }
}

Kontakt: @canerkaseler

canerkaseler
quelle
1
Vielleicht wäre eine noch bessere Lösung, eine Erweiterungsfunktion für die Aktivitätsklasse zu erstellen.
Micer
0

Ich fand Weigans Antwort am besten auf dieser Seite. Hier ist, wie Sie das verwenden können in Xamarin.Android:

public int GetScreenWidth()
{
    return Resources.System.DisplayMetrics.WidthPixels;
}

public int GetScreenHeight()
{
    return Resources.System.DisplayMetrics.HeightPixels;
}
Mehdi Dehghani
quelle
0

Die Bildschirmauflösung entspricht der Gesamtzahl der Pixel im Bildschirm. Das folgende Programm extrahiert die Bildschirmauflösung des Geräts. Es werden Bildschirmbreite und -höhe gedruckt. Diese Werte sind in Pixel angegeben.

public static Point getScreenResolution(Context context) {
// get window managers
WindowManager manager =  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Display display = manager.getDefaultDisplay();
Point point = new Point();
display.getSize(point);

 // get width and height
 int width = point.x;
 int height = point.y;

 return point;

}}

Faxriddin Abdullayev
quelle
0

Diese Dienstprogramme funktionieren mit der Größenabstraktion in Android.

Es enthält eine Klasse SizeFromDisplay.java. Sie können es folgendermaßen verwenden:

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();
Oleh Sokolov
quelle
0

Zwei schritte. Erweitern Sie zunächst die Aktivitätsklasse

class Example extends Activity

Zweitens: Verwenden Sie diesen Code

 DisplayMetrics displayMetrics = new DisplayMetrics();
 WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
 windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
 int deviceWidth = displayMetrics.widthPixels;
 int deviceHeight = displayMetrics.heightPixels;
dgamer
quelle
0
    int getScreenSize() {
        int screenSize = getResources().getConfiguration().screenLayout &
                Configuration.SCREENLAYOUT_SIZE_MASK;
//        String toastMsg = "Screen size is neither large, normal or small";
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        int orientation = display.getRotation();

        int i = 0;
        switch (screenSize) {

            case Configuration.SCREENLAYOUT_SIZE_NORMAL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_SMALL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_LARGE:
//                toastMsg = "Large screen";
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 2;
                } else {
                    i = 1;
                }


                break;
            case Configuration.SCREENLAYOUT_SIZE_XLARGE:
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 4;
                } else {
                    i = 3;
                }

                break;


        }
//        customeToast(toastMsg);
        return i;
    }
pruthwiraj.kadam
quelle
-2
       @Override
        protected void onPostExecute(Drawable result) {
            Log.d("width",""+result.getIntrinsicWidth());
            urlDrawable.setBounds(0, 0, 0+result.getIntrinsicWidth(), 600);

            // change the reference of the current drawable to the result
            // from the HTTP call
            urlDrawable.drawable = result;

            // redraw the image by invalidating the container
            URLImageParser.this.container.invalidate();

            // For ICS
            URLImageParser.this.container.setHeight((400+URLImageParser.this.container.getHeight()
                    + result.getIntrinsicHeight()));

            // Pre ICS`enter code here`
            URLImageParser.this.container.setEllipsize(null);
        }
Aruttan Aru
quelle
Bitte schreiben Sie eine Erklärung zusammen mit dem Code. Nur-Code-Antworten werden in SO
Ram Ghadiyaram