So erhalten Sie Bildschirmabmessungen als Pixel in Android

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?

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

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;

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.

(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.

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) {
}

Einfachster Weg:

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

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

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

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

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

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>

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.

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

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.

Verwenden Sie den folgenden Code in Aktivität.

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

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

DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Ich fand, dass dies den Trick tat.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

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.

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

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;

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

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

getResources().getDisplayMetrics().heightPixels;

und die Breite Größe mit

getResources().getDisplayMetrics().widthPixels; 

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;

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

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

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.

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

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
}

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

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.