So erhalten Sie Bildschirmabmessungen als Pixel in Android

1842

Ich habe einige benutzerdefinierte Elemente erstellt und möchte sie programmgesteuert in der oberen rechten Ecke platzieren ( nPixel vom oberen Rand und mPixel vom rechten Rand). Daher muss ich die Bildschirmbreite und Bildschirmhöhe ermitteln und dann die Position einstellen:

int px = screenWidth - m;
int py = screenHeight - n;

Wie bekomme ich screenWidthund screenHeightin der Hauptaktivität?

Niko Gamulin
quelle
Verwenden Sie dp anstelle von px. weil es Ihr Layout mit anderen Geräten verzerren wird ..
Jawad Zeb
Vergessen Sie nicht, mit getResources (). GetDisplayMetrics (). Dichte zu multiplizieren, um die Skalierung der Anzeige zu berücksichtigen
jmaculate
Dies beweist, dass die am besten bewertete Antwort nicht immer die beste ist (und viele Leute wiederholen die Antworten für die Wiederholung). Anstelle von getSize und der veralteten Kombination getWidth / getHeight (Fehler ignorieren) versuchen Sie es mit Balaji.K's getMetrics. Niks Kommentar in seiner Antwort erklärt sogar, getDisplayMetricswie groß die System- / Statusleiste ist. Sie können auch die Dichte als jmaculate und LoungeKatt verwenden, um den EXAKTEN Wert zu erhalten: DisplayMetrics dm = getResources().getDisplayMetrics(); float fwidth = dm.density * dm.widthPixels;Getestet in Android v2.2 (API 8) und v4.0 mit guten Ergebnissen und ohne Fehler / Warnungen .
Armfoot
DisplayMetrics displaymetrics = new DisplayMetrics (); getWindowManager (). getDefaultDisplay (). getMetrics (displaymetrics); int height = displaymetrics.heightPixels; int width = displaymetrics.widthPixels;
Azahar
eine andere Möglichkeit, die DisplayMetrics zu erhalten : Resources.getSystem().getDisplayMetrics(). Sie werden keine brauchen Context, um sie zu bekommen.
Täg

Antworten:

3478

Wenn Sie die Anzeigeabmessungen in Pixel anzeigen möchten, können Sie Folgendes verwenden getSize:

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

Wenn Sie nicht in einem sind Activity, können Sie die Standardeinstellung erhalten Displayüber WINDOW_SERVICE:

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Wenn Sie sich in einem Fragment befinden und dies ausführen möchten, verwenden Sie einfach Activity.WindowManager (in Xamarin.Android) oder getActivity (). GetWindowManager () (in Java).

Vor getSizeder Einführung (in API-Ebene 13) konnten Sie die getWidthund getHeightMethoden verwenden, die jetzt veraltet sind:

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

Für den Anwendungsfall, den Sie beschreiben, erscheint jedoch ein Rand / Abstand im Layout angemessener.

Ein anderer Weg ist: DisplayMetrics

Eine Struktur, die allgemeine Informationen zu einer Anzeige beschreibt, z. B. Größe, Dichte und Skalierung der Schriftarten. Initialisieren Sie ein Objekt wie folgt, um auf die DisplayMetrics-Mitglieder zuzugreifen:

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

Wir können verwenden widthPixels, um Informationen zu erhalten für:

"Die absolute Breite der Anzeige in Pixel."

Beispiel:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);
Josef Pfleger
quelle
13
getWidth () oder getSize ()? Was würde ich verwenden, wenn meine App sowohl auf API <13 als auch auf API> 13 ausgeführt werden soll?
Carol
52
try {display.getSize (Größe); width = size.x; Höhe = Größe.y; } catch (NoSuchMethodError e) {width = display.getWidth (); height = display.getHeight (); }
Arnaud
248
Ich verstehe nicht, warum Sie try/catchfür eine solche Prüfung verwenden möchten ? Warum nicht einfach if (android.os.Build.VERSION.SDK_INT >= 13)ohne Ausnahme verwenden? Ich halte try/catchin einem normalen App-Flow eine schlechte Praxis.
Patrik
2
@ A-Live dann würde die App auch kaputt gehen (aber nicht abstürzen). Wir Entwickler müssen trotzdem eine neue Betriebssystemversion vorab prüfen, und dies kann möglicherweise nur ein Problem verbergen. Auch mit diesem Argument könnte / sollte man alle paar Codezeilen mit try / catch umgeben, was meiner Meinung nach, wie bereits erwähnt, eine schlechte Praxis ist.
Patrik
11
Was ist, wenn Sie die Bildschirmgröße ohne Navigationsleiste und / oder Benachrichtigungsleiste erhalten möchten
Android-Entwickler
374

Ein Weg ist:

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

Es ist veraltet und Sie sollten stattdessen den folgenden Code versuchen. Die ersten beiden Codezeilen geben Ihnen die DisplayMetricsObjekte an. Dieses Objekt enthält die Felder wie heightPixels, widthPixels.

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;
Balaji.K
quelle
14
Beachten Sie, dass sich die Metriken (Breite, Höhe) abhängig von der Drehung des Geräts ändern.
Tony Chan
8
Metriken geben die Größe der Anzeige zurück, aber HoneyComb und höher, Ihre Aktivität hat weniger Speicherplatz als aufgrund der Systemleiste zurückgegeben.
Guy
3
@ Guy es hängt von deiner Implementierung ab. Sie können die Statusleiste ausblenden: requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
Hagai L
79
Existiert auch auf diese Weise: getContext (). GetResources (). GetDisplayMetrics (). WidthPixels
Nik
endgültige Float-Skala = getResources (). getDisplayMetrics (). Dichte; int width = (int) (metrics.widthPixels * scale + 0.5f); - Sie müssen die Gerätedichte berücksichtigen, wenn Sie dies tun.
Verlassener Wagen
119

Möglicherweise wird Ihre Frage nicht beantwortet, aber es kann hilfreich sein zu wissen (ich habe selbst danach gesucht, als ich zu dieser Frage kam), dass Sie die Dimension einer Ansicht benötigen, Ihr Code jedoch ausgeführt wird, wenn das Layout noch nicht festgelegt wurde (zum Beispiel in onCreate()) Sie können einen ViewTreeObserver.OnGlobalLayoutListenermit View.getViewTreeObserver().addOnGlobalLayoutListener()einrichten und den entsprechenden Code, der die Dimension der Ansicht benötigt, dort einfügen. Der Rückruf des Hörers wird aufgerufen, wenn das Layout angelegt wurde.

Francesco Feltrinelli
quelle
oder schreiben Sie einfach view.post
Lukas Hanacek
view.post funktioniert jedoch nicht garantiert. Es ist nur eine Problemumgehung.
Marsbear
@ Marsbear Wo steht, dass View.post()es nicht garantiert funktioniert? Ich bin neugierig, weil ich mich auch auf diese Methode verlasse, um die Größe einer Ansicht nach dem Layout zu ermitteln, und nicht wusste, dass sie unzuverlässig ist.
Tony Chan
@Turbo Ich sage Folgendes: p Wir haben diese Problemumgehung bereits verwendet und sie hat sich als unzuverlässig herausgestellt. Diese Problemumgehung basiert auf der Annahme, dass das anfängliche Layout innerhalb derselben UIThread-Runde wie die Initialisierung erfolgt. Daher können Sie Ihren Code so planen, dass er vor der nächsten UI-Runde über post () ausgeführt wird, und in Ordnung sein. Es stellte sich heraus, dass das Layout unter bestimmten Umständen noch länger dauern kann und die Ansicht zum Zeitpunkt der Ausführung des veröffentlichten Codes immer noch nicht gestaltet wurde. Jetzt füge ich den ViewTreeObserver in onCreate hinzu und entferne ihn nach dem ersten onLayout. Initiiere deine Sachen während des ersten onLayout.
Marsbear
@ Marsbear spielt es eine Rolle View, ViewTreeObservervon wem du das bekommst ? Oder teilen sie alle dasselbe?
Tony Chan
109

(Antwort 2012, möglicherweise veraltet) Wenn Sie Pre Honeycomb unterstützen möchten, müssen Sie vor API 13 die Abwärtskompatibilität aktivieren. So etwas wie:

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Natürlich werden die veralteten Methoden irgendwann aus den neuesten SDKs entfernt, aber obwohl wir uns immer noch darauf verlassen, dass die meisten unserer Benutzer Android 2.1, 2.2 und 2.3 haben, bleibt uns dies übrig.

digiphd
quelle
Ja, das war im Jahr 2012.
Digiphd
Entschuldigung, erlauben Sie mir zu klären, was ich meinte. Es ist höchst unwahrscheinlich, dass irgendjemand API <14 vom 22.06.2015
Sudocoder
69

Ich habe alle möglichen "Lösungen" erfolglos ausprobiert und festgestellt, dass die "Dalvik Explorer" -App von Elliott Hughes auf jeder Android-Geräte- / Betriebssystemversion immer die richtige Dimension anzeigt. Am Ende habe ich mir sein Open Source-Projekt angesehen, das hier zu finden ist: https://code.google.com/p/enh/

Hier ist der gesamte relevante Code:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

BEARBEITEN: leicht verbesserte Version (vermeiden Sie das Auslösen von Ausnahmen bei nicht unterstützten Betriebssystemversionen):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}
Dragan Marjanović
quelle
9
Dies ist der einzige Beitrag hier, der die Fensterdekorationen berücksichtigt (Statusleiste / Menüleiste). hat super für mich funktioniert.
Andy Cochrane
5
Genial, aber Sie sollten niemals mit Ausnahmen für Geschäftslogik-Feuer gerechnet haben. Ein Ausnahmefeuer (auch wenn es erwischt wird) ist für die Leistung schrecklich. Außerdem erledigen Sie mehr Arbeit als erforderlich, wenn SDK_INT> 13 ist. Stattdessen sollten Sie nur einige ifs zu Build.VERSION.SDK_INT hinzufügen.
Erik B
3
@Erik B, ich stimme zu. Ich habe eine verbesserte Version hinzugefügt. Trotzdem habe ich den Teil "seit SDK 1" verlassen, nur für den Fall, dass beim Ausprobieren etwas schief geht (ich habe viele schlechte Dinge in Android gesehen, besonders wenn Sie denken, dass es unmöglich ist, etwas falsch zu machen, deshalb möchte ich es sicher aufbewahren :)) . Auf jeden Fall sollte es nicht zu viel Aufwand geben, da diese Berechnung nur einmal durchgeführt werden sollte (z. B. könnten Werte in einigen statischen Attributen beibehalten werden).
Dragan Marjanović
8
Beachten Sie, dass dieser Code unter GPL v3 lizenziert ist, was Auswirkungen auf die Verwendung in Produktions-Apps hat.
TalkLittle
GPL und je nach Reflexion Methoden aufrufen, die in zukünftigen Android-Versionen möglicherweise nicht vorhanden sind. Mhhh
Michel
47

Einfachster Weg:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 
Zelleriation
quelle
46

Für den Zugriff auf die Höhe der Statusleiste für Android-Geräte bevorzugen wir eine programmgesteuerte Methode, um diese zu erhalten:

Beispielcode

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

Die Variable resultgibt die Höhe im Pixel an.

Für einen schnellen Zugriff

Geben Sie hier die Bildbeschreibung ein

Weitere Informationen über die Höhe Title bar, Navigation barund Content View, kindly Blick auf Android Geräten Bildschirmgrößen .

Swapnil Sonar
quelle
Genau das, was ich brauchte! getResources().getDisplayMetrics().heightPixels + resultgibt die tatsächliche Vollbildhöhe an. Die Antwort von Dragan Marjanović funktioniert auch, aber ich bevorzuge diese viel kürzere und einfachere Lösung.
Michel
Dieser Ansatz ist ab Android Marshmallow veraltet. Die Höhe der Statusleiste kann sich je nach Gerät oder Android-Version ändern. Besser nutzen OnApplyWindowInsetsListener.
Heinrich
32

HolenfindViewById() Sie sich zuerst die Ansicht (z. B. von ) und verwenden Sie dann getWidth () für die Ansicht selbst.

Marcin Gil
quelle
3
Auf diese Weise werden Sie in der Dokumentation dazu aufgefordert ... aber es ist irgendwie sinnlos, wenn Sie KEINE Ansicht verwenden. Möglicherweise verwenden Sie etwas anderes, z. B. mglsurfaceview.
GCB
2
Dies ist besser, da die übergeordnete Ansicht möglicherweise nicht die Größe der Anzeige hat. Stellen Sie jedoch sicher, dass dies an einem Punkt erfolgt, an dem die Ansicht, deren Größe Sie abfragen, bereits angelegt wurde, die normalerweise nicht in onCreate () enthalten ist. Sie können einen benutzerdefinierten Rückruf von onWindowFocusChanged (boolean hasFocus) verwenden, der aufgerufen wird, nachdem alle Ansichten gemessen wurden usw., um sicherzustellen, dass Sie keine falschen Abmessungen für die Ansicht erhalten, an der Sie interessiert sind ...
Dori
27

Ich habe zwei Funktionen, eine zum Senden des Kontexts und die andere zum Abrufen von Höhe und Breite in Pixel:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

und

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}
Jorgesys
quelle
Sie müssen @SuppressLint("NewApi")direkt über der Funktionssignatur hinzufügen , um kompilieren zu können.
Adil Malik
Ich denke, es ist besser, Höhe und Breite auf einmal zu ermitteln, als die APIs separat aufzurufen, da sie sonst möglicherweise nicht synchron sind. Dies kann passieren, wenn sich die Bildschirmausrichtung ändert, während Ihr Code ausgeführt wird.
Sam
17

Für die dynamische Skalierung mit XML gibt es ein Attribut namens "android: layout_weight".

Das folgende Beispiel, das gegenüber der Antwort von synic in diesem Thread geändert wurde , zeigt eine Schaltfläche, die 75% des Bildschirms einnimmt (Gewicht = 0,25), und eine Textansicht , die die restlichen 25% des Bildschirms einnimmt (Gewicht = 0,75).

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>
Crbreingan
quelle
17

Dies ist der Code, den ich für die Aufgabe verwende:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

Scheint sauber genug und kümmert sich dennoch um die Abwertung.

Pijusn
quelle
17

Ist das nicht eine viel bessere Lösung? DisplayMetrics enthält alles, was Sie benötigen, und funktioniert über API 1.

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

Mit getRealMetrics können Sie auch die tatsächliche Anzeige (einschließlich Bildschirmdekore wie Statusleiste oder Software-Navigationsleiste) abrufen , dies funktioniert jedoch nur bei 17+.

Vermisse ich etwas

David Corsalini
quelle
1
Es wird kein Platz für Steuerelemente auf dem Bildschirm abgezogen (z. B. auf Tablets oder Nexus-Geräten). Außerdem erhalte ich auf meinem 10-Zoll-Tablet einen anderen Wert (750 gegenüber 800), je nachdem, ob die Aktivität zum Zeitpunkt der Berechnung aktiv ist. Für meine Zwecke ist dies jedoch mehr als in Ordnung. Vielen Dank!
Steven L
15

Ich füge nur Francescos Antwort hinzu. Der andere Beobachter, der besser geeignet ist, wenn Sie den Ort im Fenster oder den Ort auf dem Bildschirm herausfinden möchten, ist ViewTreeObserver.OnPreDrawListener ()

Dies kann auch verwendet werden, um andere Attribute einer Ansicht zu finden, die zum Zeitpunkt von onCreate () größtenteils unbekannt sind, z. B. die gescrollte Position, die skalierte Position.

Pellucid
quelle
15

Verwenden Sie den folgenden Code in Aktivität.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
Vinothkumar Arputharaj
quelle
15

Finden Sie die Breite und Höhe des Bildschirms:

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

Auf diese Weise können wir das neueste und höhere SDK 13 erhalten.

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}
NagarjunaReddy
quelle
15
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;
Cristiana Chavez
quelle
12

Ich fand, dass dies den Trick tat.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);
Justin
quelle
5
Cool, aber das ist eine beängstigende Sache über diese Methode im Quellcode: dieser Kommentar
Norbert
12

Sie müssen sagen, dass Sie keine Verwendung benötigen , wenn Sie nicht in Activity, aber in View(oder eine Variable vom ViewTyp in Ihrem Bereich) sindWINDOW_SERVICE . Dann können Sie mindestens zwei Möglichkeiten verwenden.

Zuerst:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

Zweite:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

Alle diese Methoden, die wir hier aufrufen, sind nicht veraltet.

Sergei Pikalev
quelle
12
public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}
Shoaib Ahmed
quelle
11

Verwenden Sie zum Abrufen der Bildschirmabmessungen Anzeigemetriken

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

Holen Sie sich die Höhe und Breite in Pixel

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;
Sharath Kumar
quelle
9

Dies ist keine Antwort für das OP, da er die Anzeigeabmessungen in echten Pixeln haben wollte. Ich wollte die Abmessungen in "geräteunabhängigen Pixeln" und habe Antworten von hier https://stackoverflow.com/a/17880012/253938 und hier https://stackoverflow.com/a/6656774/253938 zusammengestellt mit diesem:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);
RenniePet
quelle
9

Sie können die tun bekommen Höhe Größe:

getResources().getDisplayMetrics().heightPixels;

und die Breite Größe mit

getResources().getDisplayMetrics().widthPixels; 
Jéwôm '
quelle
8

Es gibt eine nicht veraltete Möglichkeit, dies mit DisplayMetrics (API 1) zu tun, um die Unordnung beim Ausprobieren zu vermeiden:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;
paulrehkugler
quelle
8

Ich würde den getSize-Code folgendermaßen umschließen:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}
Simon
quelle
Dies stürzt auf einem Emulator mit Android 4.0 (API 14) ab.
JWW
6

Für die für die Suche nutzbar Bildschirm Dimension ohne Statusleiste und Aktionsleiste (auch dank Swapnil Antwort):

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}
Francesco Vadicamo
quelle
6

Laden Sie zuerst die XML-Datei und schreiben Sie dann diesen Code:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

Zeigen Sie Breite und Höhe entsprechend Ihrer Bildschirmauflösung an.

Duggu
quelle
6

Befolgen Sie die folgenden Methoden:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}
Sonida
quelle
6

Kotlin

fun getScreenHeight(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.heightPixels
}

fun getScreenWidth(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.widthPixels
}
Khemraj
quelle
5

Es gibt Zeiten, in denen Sie die genauen Abmessungen des verfügbaren Platzes für ein Layout in onCreate einer Aktivität kennen müssen. Nach einigem Überlegen habe ich es so ausgearbeitet.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

Wenn Sie dem Android-Manifest aus irgendeinem Grund keine weitere Aktivität hinzufügen möchten, können Sie dies folgendermaßen tun:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    
Steve Waring
quelle
Natürlich können Sie auch die Höhe im Bündel zurückgeben.
Steve Waring
5

Wenn Sie den Overhead von WindowManagern, Punkten oder Anzeigen nicht möchten, können Sie die Höhen- und Breitenattribute des obersten Ansichtselements in Ihrer XML-Datei abrufen, sofern Höhe und Breite auf match_parent festgelegt sind. (Dies gilt, solange Ihr Layout den gesamten Bildschirm einnimmt.)

Wenn Ihr XML beispielsweise mit Folgendes beginnt:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

Dann findViewById(R.id.entireLayout).getWidth()wird die Bildschirmbreite und findViewById(R.id.entireLayout).getHeight()die Bildschirmhöhe zurückgegeben.

christinac
quelle