android studio Erhalten Sie Bildschirmabmessungen in Pixeln




android studio different screen sizes (24)

Ich habe einige benutzerdefinierte Elemente erstellt und möchte sie programmatisch in der oberen rechten Ecke platzieren ( n Pixel von der oberen Kante und m Pixel von der rechten Kante). Daher muss ich die Bildschirmbreite und Bildschirmhöhe bekommen und dann die Position einstellen:

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

Wie bekomme ich screenWidth und screenHeight in der Hauptaktivität?


Einfachster Weg:

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

findViewById() Sie zuerst die Ansicht (z. B. von findViewById() ) und dann können Sie getWidth() für die Ansicht selbst verwenden.


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

Für den Zugriff auf die Höhe der Statusleiste für Android-Geräte bevorzugen wir einen programmatischen Weg, um es zu bekommen:

Beispielcode

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

Das variable result gibt die Höhe im Pixel an.

Für schnellen Zugriff

Weitere Informationen zur Höhe der Title bar , der Navigation bar und der Content View auf den Bildschirmgrößen für Android-Geräte .


Dies ist keine Antwort für das OP, da er die Anzeigedimensionen in realen Pixeln haben wollte. Ich wollte die Dimensionen in "geräteunabhängigen Pixeln", und die Antworten von hier https://.com/a/17880012/253938 und hier https://.com/a/6656774/253938 Ich kam auf 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);

Ich habe eine Splash-Screen-Aktivität mit einem LinearLayout als Root-Ansicht mit Match_parent für seine Breite und Höhe. Dies ist der Code in der onCreate() -Methode dieser Aktivität. Ich verwende diese Maßnahmen in allen anderen Aktivitäten der App.

int displayWidth = getRawDisplayWidthPreHoneycomb();
int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
pf.setScreenParameters(displayWidth, usableDisplayHeight);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
    myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
        @Override
        public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
            if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                return;
            }
            int displayWidth = Math.min(right, bottom);
            int usableDisplayHeight = Math.max(right, bottom);
            pf.setScreenParameters(displayWidth, usableDisplayHeight);
        }
    });
}

Hier sind die Implementierungen für die oben genannten Methoden:

private int getRawDisplayWidthPreHoneycomb() {
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int widthPixels = displayMetrics.widthPixels;
    int heightPixels = displayMetrics.heightPixels;

    return Math.min(widthPixels, heightPixels);
}

private int getRawDisplayHeightPreHoneycomb() {
    WindowManager w = getWindowManager();
    Display d = w.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    d.getMetrics(metrics);

    int widthPixels = metrics.widthPixels;
    int heightPixels = metrics.heightPixels;

    return Math.max(widthPixels, heightPixels);
}

public int getStatusBarHeight() {
    int statusBarHeight = 0;

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

    return statusBarHeight;
}

Daraus ergeben sich die Höhe und Breite des nutzbaren Bildschirms, mit Ausnahme aller Arten von Balken (Statusleiste, Navigationsleiste) für alle API-Versionen und verschiedene Arten von Geräten (Telefone und Tablets).


Es kann Ihre Frage vielleicht nicht beantworten, aber es könnte nützlich sein, wenn Sie eine Ansichtsdimension benötigen, aber Ihr Code wird ausgeführt, wenn sein Layout noch nicht angelegt wurde (zum Beispiel in onCreate() ) können Sie einen ViewTreeObserver.OnGlobalLayoutListener mit View.getViewTreeObserver().addOnGlobalLayoutListener() und den relevanten Code, der die Dimension der Ansicht benötigt, dort View.getViewTreeObserver().addOnGlobalLayoutListener() . Der Callback des Hörers wird aufgerufen, wenn das Layout angelegt wurde.


Sie müssen sagen, dass Sie WINDOW_SERVICE nicht benötigen, wenn Sie sich nicht in Activity , sondern in View (oder eine Variable vom Typ " View " in Ihrem Bereich haben). Dann können Sie mindestens zwei Möglichkeiten nutzen.

Zuerst:

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

Zweite:

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

All diese Methoden, die wir hier nennen, sind nicht veraltet.


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

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


Es gibt eine nicht veraltete Möglichkeit, dies mithilfe von DisplayMetrics (API 1) zu tun, wodurch die Unsichtbarkeit von try / catch vermieden wird:

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

Verwenden Sie den folgenden Code in Aktivität.

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

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.


Sie können die Höhe mit:

getResources().getDisplayMetrics().heightPixels;

und die Breite der Größe mit

getResources().getDisplayMetrics().widthPixels; 

Ich fand, dass dies der Trick war.

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

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 enthalten die DisplayMetrics-Objekte. Dieses Objekt enthält die Felder heightPixels, widthPixels.

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;

Ist das nicht eine viel bessere Lösung? DisplayMetrics kommt mit allem, was Sie brauchen und funktioniert von 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 eigentliche Anzeige (einschließlich Bildschirmdekore wie getRealMetrics oder Software-Navigationsleiste) getRealMetrics . Dies funktioniert jedoch nur bei 17+.

Fehle ich etwas?


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

Wenn Sie die Anzeigegröße in Pixeln haben möchten, können Sie getSize :

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

Wenn Sie nicht in einer Activity , können Sie die Standardanzeige über WINDOW_SERVICE :

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

Bevor getSize eingeführt wurde (in API-Ebene 13), könnten Sie die getWidth und getHeight Methoden 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, scheint jedoch ein Rand / Abstand im Layout angemessener zu sein.

22. Oktober 2015

Eine andere Möglichkeit ist: DisplayMetrics

Eine Struktur, die allgemeine Informationen zu einer Anzeige beschreibt, z. B. ihre Größe, Dichte und Schriftartenskalierung. Um auf die DisplayMetrics-Mitglieder zuzugreifen, initialisieren Sie ein Objekt wie folgt:

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

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

"Die absolute Breite der Anzeige in Pixeln."

Beispiel:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

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.


Manchmal müssen Sie die genauen Dimensionen des verfügbaren Platzes für ein Layout kennen, wenn Sie in einer Aktivität onCreate sind. Nach einigem Nachdenken habe ich diese Vorgehensweise 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 aus irgendeinem Grund dem Android-Manifest 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();
    }
}    

Finden Sie Breite und Höhe des Bildschirms:

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

Mit diesem können wir das neueste und über 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);
}

(2012 Antwort, möglicherweise veraltet) Wenn Sie vor Honeycomb unterstützen möchten, müssen Sie in Rückwärtskompatibilität vor API 13 setzen. 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 herausgenommen, aber während wir immer noch darauf vertrauen, dass die meisten unserer Benutzer Android 2.1, 2.2 und 2.3 haben, bleibt uns das übrig.


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

Hier ist der 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ützter Betriebssystemversion):

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

Wenn Sie den Overhead von WindowManagers, Points oder Displays nicht möchten, können Sie die Attribute height und width des obersten View-Elements in Ihrem XML-Code abrufen, vorausgesetzt, seine Höhe und Breite sind auf "match_parent" eingestellt. (Dies gilt, solange Ihr Layout den gesamten Bildschirm einnimmt.)

Zum Beispiel, wenn Ihr XML mit so etwas 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() gibt die Bildschirmbreite zurück und findViewById(R.id.entireLayout).getHeight() gibt die Höhe des Bildschirms zurück.





dimensions