Jak uzyskać wymiary ekranu jako piksele w Androidzie

Utworzyłem niektóre niestandardowe elementy i chcę programowo umieścić je w prawym górnym rogu ( npiksele od górnej krawędzi i mpiksele od prawej krawędzi). Dlatego muszę uzyskać szerokość i wysokość ekranu, a następnie ustawić pozycję:

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

W jaki sposób uzyskać screenWidthi screenHeightw głównej działalności?

Jeśli chcesz wymiary wyświetlania w pikselach, możesz użyć getSize:

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

Jeśli nie ma Cię w domu Activity, możesz uzyskać ustawienia domyślne Displaypoprzez WINDOW_SERVICE:

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

Jeśli jesteś we fragmencie i chcesz to osiągnąć, po prostu użyj Activity.WindowManager (w Xamarin.Android) lub getActivity (). GetWindowManager () (w java).

Przed getSizewprowadzeniem (na poziomie API 13) można było użyć metod getWidthi getHeight, które są teraz przestarzałe:

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

Jednak w opisywanym przypadku użycia margines / wypełnienie układu wydaje się bardziej odpowiednie.

Innym sposobem jest: DisplayMetrics

Struktura opisująca ogólne informacje o ekranie, takie jak jego rozmiar, gęstość i skalowanie czcionek. Aby uzyskać dostęp do elementów DisplayMetrics, zainicjuj obiekt w następujący sposób:

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

Możemy użyć, widthPixelsaby uzyskać informacje na temat:

„Bezwzględna szerokość wyświetlacza w pikselach”.

Przykład:

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

Jednym ze sposobów jest:

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

Jest przestarzały i powinieneś zamiast tego wypróbować następujący kod. Pierwsze dwa wiersze kodu zawierają DisplayMetricsobjecs. Te obiekty znajdują się pola, na przykład heightPixels, widthPixels.

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

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

Może nie odpowiedzieć na twoje pytanie, ale warto wiedzieć (szukałem go sam, kiedy przyszedłem do tego pytania), że jeśli potrzebujesz wymiaru Widoku, ale kod jest wykonywany, gdy jego układ nie został jeszcze ułożony (na przykład w onCreate()) możesz ustawić za ViewTreeObserver.OnGlobalLayoutListenerpomocą View.getViewTreeObserver().addOnGlobalLayoutListener()i wstawić odpowiedni kod, który potrzebuje wymiaru widoku. Oddzwonienie nasłuchiwania zostanie wywołane, gdy układ zostanie ułożony.

(Odpowiedź z 2012 r. Może być nieaktualna) Jeśli chcesz obsługiwać wersję wcześniejszą o strukturze plastra miodu, musisz wprowadzić wsteczną zgodność przed API 13. Coś takiego:

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

Oczywiście przestarzałe metody zostaną w końcu usunięte z najnowszych zestawów SDK, ale chociaż nadal polegamy na większości naszych użytkowników posiadających Androida 2.1, 2.2 i 2.3, pozostaje nam to.

Bezskutecznie wypróbowałem wszystkie możliwe „rozwiązania” i zauważyłem, że aplikacja „Dalvik Explorer” Elliotta Hughesa zawsze pokazuje prawidłowy wymiar na dowolnej wersji urządzenia / systemu Android. Skończyło się na jego projekcie open source, który można znaleźć tutaj: https://code.google.com/p/enh/

Oto cały odpowiedni kod:

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

EDYCJA: nieco ulepszona wersja (unikaj wyzwalania wyjątków w nieobsługiwanej wersji systemu operacyjnego):

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

Najprostszy sposób:

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

Aby uzyskać dostęp do wysokości paska stanu dla urządzeń z Androidem, preferujemy programowy sposób jej uzyskania:

Przykładowy kod

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

Zmienna resultpodaje wysokość w pikselu.

Szybki dostęp

Aby uzyskać więcej informacji na temat wysokości Title bar, Navigation bari Content View, uprzejmie wygląd na ekranie Android Device rozmiarach .

Najpierw pobierz widok (np. Przez findViewById()), a następnie możesz użyć getWidth () na samym widoku.

Mam dwie funkcje, jedną do wysyłania kontekstu, a drugą do uzyskiwania wysokości i szerokości w pikselach:

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

i

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

Do dynamicznego skalowania za pomocą XML istnieje atrybut o nazwie „android: layout_weight”

Poniższy przykład, zmodyfikowany na podstawie odpowiedzi synic na ten wątek , pokazuje przycisk, który zajmuje 75% ekranu (waga = 0,25) oraz widok tekstowy zajmujący pozostałe 25% ekranu (waga = 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>

Oto kod, którego używam do zadania:

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

Wydaje się wystarczająco czysty, a jednak zajmuje się deprecjacją.

Czy to nie jest o wiele lepsze rozwiązanie? DisplayMetrics zawiera wszystko, czego potrzebujesz i działa z 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;
}

Możesz także uzyskać rzeczywisty obraz (w tym dekory ekranu, takie jak pasek stanu lub pasek nawigacji oprogramowania) za pomocą getRealMetrics , ale działa to tylko w przypadku 17+.

Czy coś brakuje?

Właśnie dodając do odpowiedzi Francesco. Innym obserwatorem, który jest bardziej odpowiedni, jeśli chcesz dowiedzieć się o lokalizacji w oknie lub lokalizacji na ekranie, jest ViewTreeObserver.OnPreDrawListener ()

Można to również wykorzystać do znalezienia innych atrybutów widoku, które są w większości nieznane w czasie onCreate (), np. Pozycja przewijana, pozycja skalowana.

Używanie następującego kodu w działaniu.

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

Znajdź szerokość i wysokość ekranu:

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

Korzystając z tego, możemy uzyskać najnowszy i wyższy zestaw SDK 13.

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

Uważam, że to załatwiło sprawę.

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

Trzeba powiedzieć, że jeśli nie jesteś w Activity, ale Viewmasz (lub masz zmienną Viewtypu w swoim zakresie), nie musisz tego używać WINDOW_SERVICE. Następnie możesz użyć co najmniej dwóch sposobów.

Pierwszy:

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

Druga:

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

Wszystkie te metody, które tu nazywamy, nie są przestarzałe.

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

Aby uzyskać wymiary ekranu, użyj mierników wyświetlacza

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

Uzyskaj wysokość i szerokość w pikselach

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

To nie jest odpowiedź dla OP, ponieważ chciał wymiary wyświetlacza w rzeczywistych pikselach. Chciałem wymiary w „niezależny od urządzenia-pikseli” i umieszczenie odpowiedzi razem stąd https://stackoverflow.com/a/17880012/253938 i tutaj https://stackoverflow.com/a/6656774/253938 wymyśliłem z tym:

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

Możesz uzyskać wysokość, używając:

getResources().getDisplayMetrics().heightPixels;

i szerokość za pomocą

getResources().getDisplayMetrics().widthPixels; 

Istnieje nieaktualny sposób na wykonanie tego za pomocą DisplayMetrics (API 1), który pozwala uniknąć bałaganu try / catch:

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

Owinąłbym kod getSize w ten sposób:

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

Dla kogo szuka użytkowej wymiaru ekranu bez paska stanu i działania Bar (także dzięki za odpowiedź Swapnil):

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

Najpierw załaduj plik XML, a następnie napisz ten kod:

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

Pokaż szerokość i wysokość zgodnie z rozdzielczością ekranu.

Postępuj zgodnie z poniższymi metodami:

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
}

Są chwile, kiedy trzeba znać dokładne wymiary dostępnej przestrzeni dla układu, gdy jest onCreate działania. Po namyśle opracowałem ten sposób.

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

Jeśli z jakiegoś powodu nie chcesz dodać innej aktywności do manifestu Androida, możesz to zrobić w ten sposób:

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

Jeśli nie chcesz nakładać się na menedżery okien, punkty lub wyświetlacze, możesz pobrać atrybuty wysokości i szerokości najwyższego elementu widoku w pliku XML, pod warunkiem, że jego wysokość i szerokość są ustawione na match_parent. (Dzieje się tak, o ile układ zajmuje cały ekran).

Na przykład, jeśli twój XML zaczyna się od czegoś takiego:

<?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" >

Następnie findViewById(R.id.entireLayout).getWidth()zwróci szerokość ekranu i findViewById(R.id.entireLayout).getHeight()zwróci wysokość ekranu.