it-swarm.com.ru

Получить размеры экрана в пикселях

Я создал несколько пользовательских элементов и хочу программно поместить их в верхний правый угол (n пикселей от верхнего края и m пикселей от правого края). Поэтому мне нужно получить ширину экрана и высоту экрана, а затем установить положение:

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

Как я могу получить screenWidth и screenHeight в основной деятельности?

1740
Niko Gamulin

Если вам нужны размеры экрана в пикселях, вы можете использовать getSize :

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

Если вы не находитесь в Activity, вы можете получить значение Display по умолчанию через WINDOW_SERVICE:

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

Если вы находитесь во фрагменте и хотите выполнить это, просто используйте Activity.WindowManager (в Xamarin.Android) или getActivity (). GetWindowManager () (в Java).

До введения getSize (на уровне API 13) вы могли использовать методы getWidth и getHeight, которые в настоящее время устарели:

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

Однако для описываемого вами варианта использования поле/отступ в макете кажется более подходящим.

Другой способ: DisplayMetrics

Структура, описывающая общую информацию об отображении, такую ​​как его размер, плотность и масштабирование шрифта. Чтобы получить доступ к членам DisplayMetrics, инициализируйте объект следующим образом:

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

Мы можем использовать widthPixels для получения информации для: 

«Абсолютная ширина дисплея в пикселях.»

Пример:

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

Одним из способов является:

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

Это устарело, и вы должны вместо этого попробовать следующий код. Первые две строки кода дают вам объекты DisplayMetrics. Этот объект содержит поля, такие как heightPixels, widthPixels.

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

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

Возможно, он не отвечает на ваш вопрос, но было бы полезно знать (я сам искал его, когда пришел к этому вопросу), что если вам нужно измерение View, но ваш код выполняется, когда его макет еще не выложен (например, в onCreate()) вы можете установить ViewTreeObserver.OnGlobalLayoutListener с помощью View.getViewTreeObserver().addOnGlobalLayoutListener() и поместить туда соответствующий код, который нуждается в измерении представления. Обратный вызов слушателя будет вызван, когда макет будет размечен.

114
Francesco Feltrinelli

(Ответ 2012 г., возможно, устарел). Если вы хотите поддерживать предварительно Honeycomb, вам нужно будет установить обратную совместимость до API 13. Что-то вроде:

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

Конечно, устаревшие методы в конечном итоге будут удалены из самых последних SDK, но, хотя мы по-прежнему полагаемся на большинство наших пользователей, имеющих Android 2.1, 2.2 и 2.3, это то, что нам осталось.

104
digiphd

Я безуспешно перепробовал все возможные «решения» и заметил, что приложение «Dalvik Explorer» Эллиотта Хьюза всегда показывает правильный размер на любом устройстве Android/версии ОС. В итоге я посмотрел на его проект с открытым исходным кодом, который можно найти здесь: https://code.google.com/p/enh/

Вот весь соответствующий код:

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

Правка: слегка улучшенная версия (избегать исключений запуска на не поддерживаемой версии ОС):

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
Dragan Marjanović

Самый простой способ: 

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

Для доступа к высоте строки состояния для устройств Android мы предпочитаем программный способ получить ее:

Образец кода

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

Переменная result дает высоту в пикселе.

Для быстрого доступа

Enter image description here

Для получения дополнительной информации о высоте Title bar, Navigation bar и Content View, пожалуйста, просмотрите Размеры экрана устройства Android.

46
Swapnil Sonar

Сначала получите представление (например, с помощью findViewById()), а затем вы можете использовать getWidth () для самого представления.

30
Marcin Gil

У меня есть две функции, одна для отправки контекста, а другая для получения высоты и ширины в пикселях:

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

а также

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

Вот код, который я использую для задачи:

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

Кажется достаточно чистым и все же, заботится об амортизации.

17
Pijusn

Разве это не намного лучшее решение? DisplayMetrics поставляется со всем необходимым и работает с 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;
}

Вы также можете получить фактическое отображение (включая декоры экрана, такие как строка состояния или панель программного обеспечения), используя getRealMetrics , но это работает только на 17+.

Я что-то пропустил?

17
David Corsalini

Для динамического масштабирования с использованием XML есть атрибут «Android: layout_weight» 

Приведенный ниже пример, модифицированный из ответа synic на этот поток , показывает кнопку, занимающую 75% экрана (вес = .25), и текстовое представление, занимающее оставшиеся 25% экрана (вес =. 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

Найдите ширину и высоту экрана:

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

Используя это, мы можем получить последнюю версию 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);
}
15
NagarjunaReddy

Просто добавлю к ответу Франческо. Другим более подходящим наблюдателем, если вы хотите узнать местоположение в окне или местоположение на экране, является ViewTreeObserver.OnPreDrawListener ()

Это также может быть использовано для поиска других атрибутов представления, которые в основном неизвестны во время onCreate (), например прокручиваемая позиция, масштабированная позиция.

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

Используя следующий код в Activity.

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

Я обнаружил, что сделал свое дело.

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

Нужно сказать, что если вы находитесь не в Activity, а в View (или в вашей области видимости есть переменная типа View), нет необходимости использовать WINDOW_SERVICE. Тогда вы можете использовать как минимум два способа.

Первый:

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

Во-вторых:

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

Все эти методы, которые мы здесь называем, не устарели.

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
Shoaib Ahmed Khan

Для получения размеров экрана используйте метрики отображения

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

Получите высоту и ширину в пикселях

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

Это не ответ для ОП, так как он хотел, чтобы размеры дисплея отображались в реальных пикселях. Я хотел, чтобы размеры были в «независимых от устройства пикселях», и собирал ответы здесь https://stackoverflow.com/a/17880012/253938 и здесь https://stackoverflow.com/a/ 6656774/253938 я придумал это:

    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

Существует не осуждаемый способ сделать это с помощью DisplayMetrics (API 1), который позволяет избежать путаницы в попытках/отлове:

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

Вы можете получить height size используя:

getResources().getDisplayMetrics().heightPixels;

и ширина размер с помощью

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

Я бы обернул код getSize следующим образом:

@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

Сначала загрузите файл XML, а затем напишите этот код:

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

Показать ширину и высоту в соответствии с вашим разрешением экрана.

5
duggu

Следуйте методам ниже:

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

Для тех, кто ищет полезный размер экрана без Строка состояния и Панель действий (также благодаря ответу 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);
}
5
Francesco Vadicamo

Есть моменты, когда вам нужно знать точные размеры доступного пространства для макета, когда он находится в действии onCreate .... После некоторого размышления я разработал этот способ.

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

Если по какой-то причине вы не хотите добавлять другое действие в манифест Android, вы можете сделать это следующим образом:

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

Если вам не нужны служебные данные WindowManager, Points или Displays, вы можете получить атрибуты высоты и ширины самого верхнего элемента View в XML-файле, если для его высоты и ширины установлено значение match_parent. (Это верно, пока ваш макет занимает весь экран.)

Например, если ваш XML начинается с чего-то вроде этого:

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

Затем findViewById(R.id.entireLayout).getWidth() вернет ширину экрана, а findViewById(R.id.entireLayout).getHeight() вернет высоту экрана.

4
christinac

У меня есть заставка с LinearLayout в качестве корневого представления, которое имеет match_parent для его ширины и высоты. Это код в методе onCreate() этого действия. Я использую эти меры во всех других видах деятельности приложения.

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

Вот реализации методов, которые вы видите, вызываются выше:

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

Это приводит к высоте и ширине используемого дисплея, за исключением полос любого типа (строка состояния, панель навигации), для всех версий API и различных типов устройств (телефоны и планшеты).

3
Rutger

Котлин

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

Ответ выше не будет работать, если класс Display не будет работать, тогда вы можете получить ширину и высоту с помощью метода ниже.

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
Maharshi Saparia

Простая функция, совместимая с более низкими версиями.

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

Использовать:

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

Вот простая адаптация из некоторых ответов выше в реализации Kotlin. Для этого требуется, как указано выше, windowsSoftInput = "AdjustResize" в манифесте:

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

И использовать:

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

Эта функция возвращает приблизительный размер экрана в дюймах.

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;

Если getSize выдает ошибку из-за вашего minSDKVersion и вы не хотите использовать устаревшие методы (getWidth & getHeight), решение getMetrics было изначально опубликовано в 2011 году Balaji.K ... И Ник добавил комментарий, объясняющий, что getDisplayMetrics также считает размер строки состояния.

Некоторые другие комментарии относятся к умножению на шкалу ( плотность ), чтобы получить точное значение с плавающей точкой измерений. Протестировано в Android v2.2 (API 8) и v4.0 с хорошими результатами и без ошибок/предупреждений .

0
Armfoot

Я думаю это самое простое

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

Я использовал вышеуказанные предложения и создал версию kotlin для нашего вопроса. Надеюсь, что это даст дополнительную помощь тем, кто использует kotlin:

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

Обратите внимание, что высота, возвращаемая этими API , будет МЕНЬШЕ, чем физическая высота устройства , потому что высота панели кнопок вычитается.

Например: на Moto X4 он возвращает правильные значения widthPixels (1080), но возвращает высоту 1776, даже если экран устройства имеет высоту 1920 пикселей.

0
Tyler