wake-up-neo.com

Ermitteln Sie die Bildschirmabmessungen in Pixel

Ich habe einige benutzerdefinierte Elemente erstellt und möchte sie programmgesteuert in die obere rechte Ecke setzen (n Pixel vom oberen Rand und m Pixel vom rechten Rand). Daher muss ich die Bildschirmbreite und die Bildschirmhöhe ermitteln und dann die Position einstellen:

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

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

1740
Niko Gamulin

Wenn Sie die Anzeigeabmessungen in Pixel wünschen, können Sie getSize verwenden:

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

Wenn Sie sich nicht in einer Activity befinden, können Sie die Standardvariante Display über WINDOW_SERVICE erhalten:

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

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

Vor der Einführung von getSize (in API-Ebene 13) konnten 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 geeigneter zu sein.

Ein anderer Weg ist: DisplayMetrics

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

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

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

"Die absolute Breite der Anzeige in Pixel."

Beispiel:

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

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 ausprobieren. In den ersten beiden Codezeilen erhalten Sie die DisplayMetrics-Objekte. Dieses Objekt enthält Felder wie heightPixels, widthPixels.

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;
359
Balaji.K

Es kann Ihre Frage nicht beantworten, aber es könnte nützlich sein zu wissen (ich habe selbst danach gesucht, als ich zu dieser Frage kam), dass Sie die Dimension einer View benötigen, aber Ihr Code ausgeführt wird, wenn das Layout noch nicht ausgelegt wurde (zum Beispiel in onCreate()) können Sie einen ViewTreeObserver.OnGlobalLayoutListener mit View.getViewTreeObserver().addOnGlobalLayoutListener() einrichten und den entsprechenden Code einfügen, der die Dimension der Ansicht benötigt. Der Callback des Listeners wird aufgerufen, wenn das Layout angelegt wurde.

114

(Antwort 2012, möglicherweise veraltet) Wenn Sie Pre-Honeycomb unterstützen möchten, müssen Sie vor API 13 Abwärtskompatibilität einsetzen. 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 letztendlich aus den neuesten SDKs entfernt, aber obwohl wir immer noch darauf angewiesen sind, dass die meisten unserer Benutzer Android 2.1, 2.2 und 2.3 haben, bleiben wir dabei.

104
digiphd

Ich habe alle möglichen "Lösungen" erfolglos ausprobiert und habe bemerkt, dass die "Dalvik Explorer" -App von Elliott Hughes auf jeder Android-Geräte-/Betriebssystemversion immer die richtige Größe 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 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 (Ausnahmen bei nicht unterstützten Betriebssystemversionen vermeiden):

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

Einfachste Möglichkeit: 

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

Um auf die Höhe der Statusleiste für Android-Geräte zuzugreifen, bevorzugen wir eine programmgesteuerte Methode:

Beispielcode

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

Die Variable result gibt die Höhe im Pixel an.

Für einen schnellen Zugriff

Enter image description here

Weitere Informationen zur Höhe von Title bar, Navigation bar und Content View finden Sie unter Bildschirmgrößen der Android-Geräte.

46
Swapnil Sonar

Holen Sie sich zuerst view (zB durch findViewById()) und dann können Sie getWidth () für die View selbst verwenden.

30
Marcin Gil

Ich habe zwei Funktionen, eine zum Senden des Kontexts und die andere zum Erhalten 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;
}
26
Elenasys

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.

17
Pijusn

Ist das nicht eine viel bessere Lösung? DisplayMetrics enthält alles, was Sie benötigen und funktioniert mit 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;
}

Sie können die tatsächliche Anzeige (einschließlich Bildschirmdekore, z. B. Statusleiste oder Software-Navigationsleiste) auch mit getRealMetrics aufrufen. Dies funktioniert jedoch nur bei 17+.

Fehlt mir etwas?

17
David Corsalini

Für die dynamische Skalierung mit XML gibt es ein Attribut mit der Bezeichnung "Android: layout_weight". 

Das folgende Beispiel, das von der Antwort von synic auf this thread modifiziert wurde, zeigt eine Schaltfläche, die 75% des Bildschirms beansprucht (Gewicht = 0,25) und eine Textansicht, die die restlichen 25% des Bildschirms (Gewicht =. 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>
17
Crbreingan

Finden Sie die Breite und Höhe des Bildschirms:

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

Damit 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);
}
15
NagarjunaReddy

Ich füge einfach Francescos Antwort hinzu. Der andere Beobachter, der treffender ist, wenn Sie die Position im Fenster oder die Position im Bildschirm ermitteln möchten, lautet ViewTreeObserver.OnPreDrawListener ()

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

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

Verwenden Sie den folgenden Code in Activity.

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

Ich habe festgestellt, dass dies gelungen ist.

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

Wenn Sie sich nicht in Activity, sondern in View befinden (oder eine Variable vom Typ View in Ihrem Gültigkeitsbereich haben), müssen Sie nicht WINDOW_SERVICE verwenden. 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 nennen, sind nicht veraltet.

11
Sergei Pikalev
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);
    }
}
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);
    }

Ermitteln Sie die Höhe und Breite in Pixel

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;
9
Anonymous

Dies ist keine Antwort für das OP, da er die Anzeigeabmessungen in realen Pixeln wollte. Ich wollte die Abmessungen in "geräteunabhängigen Pixeln" und die Antworten hier zusammenstellen https://stackoverflow.com/a/17880012/253938 und hier https://stackoverflow.com/a/ 6656774/253938 Ich kam dazu:

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

Es gibt einen nicht veralteten Weg, dies mit DisplayMetrics (API 1) zu tun, um das Try/Catch-Verhalten 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;
7
paulrehkugler

Sie können die height size mit:

getResources().getDisplayMetrics().heightPixels;

und die width size mit

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

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

@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;
}
7
Simon Heinen

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.

5
duggu

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

Für wen sucht nutzbare Bildschirmgröße ohne Statusleiste und Aktionsleiste (auch dank Swapnils 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);
}
5

Es gibt Zeiten, in denen Sie die genauen Abmessungen des verfügbaren Platzes für ein Layout kennen müssen, wenn onCreate ..__ einer Aktivität in einer Aktivität ausgeführt wird.

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 keine weitere Aktivität zum Android-Manifest 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();
    }
}    
4
Steve Waring

Wenn Sie nicht den Overhead von WindowManagers, Points oder Displays verwenden möchten, können Sie die Höhen- und Breitenattribute des obersten View-Elements in Ihrem XML übernehmen, vorausgesetzt, dass Höhe und Breite auf match_parent gesetzt sind. (Dies gilt, solange Ihr Layout den gesamten Bildschirm einnimmt.)

Wenn zum Beispiel Ihr XML mit etwas wie dem folgenden 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 gibt findViewById(R.id.entireLayout).getWidth() die Breite des Bildschirms und findViewById(R.id.entireLayout).getHeight() die Höhe des Bildschirms zurück.

4
christinac

Ich habe eine Splash-Screen-Aktivität mit einem LinearLayout als Root-Ansicht, das match_parent für seine Breite und Höhe hat. Dies ist der Code in der onCreate()-Methode dieser Aktivität. Diese Maßnahmen wende ich bei allen anderen Aktivitäten der App an.

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 ergibt sich für alle API-Versionen und verschiedene Gerätetypen (Telefone und Tablets) die Höhe und Breite der verwendbaren Anzeige, ausgenommen jegliche Art von Bars (Statusleiste, Navigationsleiste).

3
Rutger

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
}
2
Khemraj

Die obige Antwort funktioniert nicht, wenn die Display-Klasse nicht funktioniert. Dann können Sie die Breite und Höhe anhand der unten angegebenen Methode ermitteln.

private static final int WIDTH_INDEX = 0;
private static final int HEIGHT_INDEX = 1;

    public static int[] getScreenSize(Context context) {
        int[] widthHeight = new int[2];
        widthHeight[WIDTH_INDEX] = 0;
        widthHeight[HEIGHT_INDEX] = 0;

        try {
            WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Display display = windowManager.getDefaultDisplay();

            Point size = new Point();
            display.getSize(size);
            widthHeight[WIDTH_INDEX] = size.x;
            widthHeight[HEIGHT_INDEX] = size.y;

            if (!isScreenSizeRetrieved(widthHeight))
            {
                DisplayMetrics metrics = new DisplayMetrics();
                display.getMetrics(metrics);
                widthHeight[0] = metrics.widthPixels;
                widthHeight[1] = metrics.heightPixels;
            }

            // Last defense. Use deprecated API that was introduced in lower than API 13
            if (!isScreenSizeRetrieved(widthHeight)) {
                widthHeight[0] = display.getWidth(); // deprecated
                widthHeight[1] = display.getHeight(); // deprecated
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return widthHeight;
    }

    private static boolean isScreenSizeRetrieved(int[] widthHeight) {
        return widthHeight[WIDTH_INDEX] != 0 && widthHeight[HEIGHT_INDEX] != 0;
    }
2

Einfache Funktion auch mit niedrigeren Versionen kompatibel.

/**
 * @return screen size int[width, height]
 *
 * */
public int[] getScreenSize(){
    Point size = new Point();
    WindowManager w = getWindowManager();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2){
        w.getDefaultDisplay().getSize(size);
        return new int[]{size.x, size.y};
    }else{
        Display d = w.getDefaultDisplay();
        //noinspection deprecation
        return new int[]{d.getWidth(), d.getHeight()};
    }
}

Benutzen:

int width = getScreenSize()[0];
int height = getScreenSize()[1];
1
Jakob

Hier ist eine einfache Anpassung aus einigen Antworten oben in einer Kotlin-Implementierung. Es erfordert wie oben erwähnt windowsSoftInput = "adjustResize" im Manifest:

class KeyboardWatcher(private val layoutRooView: View) {

    companion object {
        private const val MIN_KEYBOARD_HEIGHT = 200f
    }

    private val displayMetrics: DisplayMetrics = layoutRooView.resources.displayMetrics
    private var stateVisible = false

    var observer: ((Boolean) -> Unit)? = null

    init {
        layoutRooView.viewTreeObserver.addOnGlobalLayoutListener {
            val heightDiff = layoutRooView.rootView.height - layoutRooView.height
            if (!stateVisible && heightDiff > dpToPx(MIN_KEYBOARD_HEIGHT)) {
                stateVisible = true
                observer?.invoke(stateVisible)
            } else if(stateVisible) {
                stateVisible = false
                observer?.invoke(stateVisible)
            }
        }
    }

    private fun dpToPx(valueInDp: Float): Float {
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, displayMetrics)
    }
}

Und zu verwenden:

val activityRootView = findViewById<ViewGroup>(R.id.activityRoot)
KeyboardWatcher(activityRootView).observer = { visible ->
    if (visible) do something here ...
}
1
Joao Gavazzi

Diese Funktion gibt die ungefähre Bildschirmgröße in Zoll zurück.

public double getScreenSize()
{
        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        int width=dm.widthPixels;
        int height=dm.heightPixels;
        int dens=dm.densityDpi;
        double wi=(double)width/(double)dens;
        double hi=(double)height/(double)dens;
        double x = Math.pow(wi,2);
        double y = Math.pow(hi,2);
        double screenInches = Math.sqrt(x+y);
        return screenInches;
}
1
Abhishek
DisplayMetrics dm = getResources().getDisplayMetrics();
float fwidth = dm.density * dm.widthPixels;
float fheight = dm.density * dm.heightPixels;

Wenn Sie mit getSize einen Fehler aufgrund Ihrer minSDKVersion erhalten und keine veralteten Methoden verwenden möchten (getWidth & getHeight), wurde die getMetrics-Lösung ursprünglich von Balaji.K im Jahr 2011 gepostet. Außerdem hat Nik einen Kommentar zu getDisplayMetrics in Betracht gezogen die Größe der Statusleiste.

Einige andere Kommentare beziehen sich auf das Multiplizieren mit der Skala ( Dichte ), um den genauen Gleitkommawert der Bemaßungen zu erhalten. Getestet in Android v2.2 (API 8) und v4.0 mit guten Ergebnissen und keine Fehler/Warnungen .

0
Armfoot

Ich denke es ist am einfachsten

private fun checkDisplayResolution() {
    val displayMetrics = DisplayMetrics().also {
        windowManager.defaultDisplay.getMetrics(it)
    }

    Log.i(TAG, "display width: ${displayMetrics.widthPixels}")
    Log.i(TAG, "display height: ${displayMetrics.heightPixels}")
    Log.i(TAG, "display width dpi: ${displayMetrics.xdpi}")
    Log.i(TAG, "display height dpi: ${displayMetrics.ydpi}")
    Log.i(TAG, "display density: ${displayMetrics.density}")
    Log.i(TAG, "display scaled density: ${displayMetrics.scaledDensity}")
}
0
Artem Botnev

Ich habe die obigen Vorschläge verwendet und eine Kotlin-Version für unsere Frage erstellt. Hoffe, dies bietet einige zusätzliche Hilfe für diejenigen, die Kotlin verwenden:

private val screenDimensions: Int by lazy {
    val display = (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
    Point()
        .also { size ->
            when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 -> display.getRealSize(size)
                else -> display.getSize(size)
            }
        }
}

screenDimensions.x // width
screenDimensions.y // height
0
Mike T

Beachten Sie, dass die von diesen APIs zurückgegebene Höhe WENIGER als die physische Höhe des Geräts ist , da die Höhe der Schaltflächenleiste abgezogen wird.

Beispiel: Auf einem Moto X4 werden die korrekten widthPixel (1080) zurückgegeben, es wird jedoch eine Höhe von 1776 zurückgegeben, obwohl der Bildschirm des Geräts 1920 Pixel hoch ist.

0
Tyler