Экран
Небольшая подборка различных примеров для работы с экраном. На самом деле их не так часто приходится использовать в практике, но иметь общее представление бывает необходимым. Начало было положено в 2012 году, что-то могло устареть.
Настройки — Экран
Чтобы показать окно Экран из системного приложения Настройки:
// Kotlin val intent = Intent(Settings.ACTION_DISPLAY_SETTINGS) if (intent.resolveActivity(packageManager) != null) < startActivity(intent) >
// Java Intent intent = new Intent(Settings.ACTION_DISPLAY_SETTINGS); if (intent.resolveActivity(getPackageManager()) != null)
Размеры экрана и его ориентация (Старый и новый способ)
Чтобы узнать размеры экрана и его ориентацию из запущенного приложения, можно воспользоваться встроенными классами Android.
public void onClick(View v) < // Получим Display из the WindowManager Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)) .getDefaultDisplay(); // Теперь получим необходимую информацию String width = Integer.toString(display.getWidth()); String height = Integer.toString(display.getHeight()); String orientation = Integer.toString(display.getOrientation()); String info = "Ширина: " + width + "; Высота: " + height + "; Ориентация: " + orientation; TextView infoTextView = findViewById(R.id.textViewInfo); infoTextView.setText(info); >
Данный способ был опубликован в те времена, когда у меня был Android 2.3. Читатели подсказали, что теперь методы считаются устаревшими (API 13 и выше). Пришлось переписывать код. Впрочем, спустя некоторое время и этот код стал считаться устаревшим.
// Kotlin val display: Display = windowManager.defaultDisplay val point = Point() display.getSize(point) val screenWidth: Int = point.x val screenHeight: Int = point.y // Теперь получим необходимую информацию val width = Integer.toString(screenWidth) val height = Integer.toString(screenHeight) val info = "Ширина: $width; Высота: $height" Log.i("Screen", info)
// Java public void onClick(View v) < Display display = getWindowManager().getDefaultDisplay(); Point point = new Point(); display.getSize(point); int screenWidth = point.x; int screenHeight = point.y; // Теперь получим необходимую информацию String width = Integer.toString(screenWidth); String height = Integer.toString(screenHeight); String info = "Ширина: " + width + "; Высота: " + height; TextView infoTextView = findViewById(R.id.textViewInfo); infoTextView.setText(info); >
Ориентацию при помощи нового метода не узнаешь. Помните, что это размеры экрана устройства, а не экрана вашего приложения. Кроме того, в документации как-то туманно описывается точность вычислений этих размеров. Никому верить нельзя.
Плотность экрана, масштабирование шрифта и др.
Существует класс DisplayMetrics, также имеющий в своём составе свойства для экрана. Пример также пришлось переписывать после выхода Android 11 (API 30), который теперь тоже устаревший:
// Kotlin button.setOnClickListener < var screen = "" val metrics = DisplayMetrics() if (Build.VERSION.SDK_INT >= 30) < display?.apply < getRealMetrics(metrics) screen = """ Width: $pixels Height: $ pixels The Logical Density: $ X Dimension: $ dot/inch Y Dimension: $ dot/inch The screen density expressed as dots-per-inch: $ A scaling factor for fonts displayed on the display: $ """ > >else < // getMetrics() method was deprecated in api level 30 windowManager.defaultDisplay.getMetrics(metrics) screen = """ Width: $pixels Height: $ pixels The Logical Density: $ X Dimension: $ dot/inch Y Dimension: $ dot/inch The screen density expressed as dots-per-inch: $ A scaling factor for fonts displayed on the display: $""" > val infoTextView = findViewById(R.id.textView) infoTextView.text = screen >
// Java DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics); String strScreen = ""; strScreen += "Width: " + String.valueOf(metrics.widthPixels) + " pixels" + "\n"; strScreen += "Height: " + String.valueOf(metrics.heightPixels) + " pixels" + "\n"; strScreen += "The Logical Density: " + String.valueOf(metrics.density) + "\n"; strScreen += "X Dimension: " + String.valueOf(metrics.xdpi) + " dot/inch" + "\n"; strScreen += "Y Dimension: " + String.valueOf(metrics.ydpi) + " dot/inch" + "\n"; strScreen += "The screen density expressed as dots-per-inch: " + metrics.densityDpi + "\n"; strScreen += "A scaling factor for fonts displayed on the display: " + metrics.scaledDensity + "\n"; TextView infoTextView = findViewById(R.id.textViewInfo); infoTextView.setText(strScreen);
Вот ещё несколько способов определения размеров:
if((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_LARGE) == Configuration.SCREENLAYOUT_SIZE_LARGE)< //do something for Screen layout large >else < //do something >
Такой же код, но с использованием дополнительной константы SCREENLAYOUT_SIZE_MASK:
// Определение размера экрана int screenSize = getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK; // Если планшет if (screenSize == Configuration.SCREENLAYOUT_SIZE_LARGE || screenSize == Configuration.SCREENLAYOUT_SIZE_XLARGE ) mIsPhone = false; // Не телефон. какая-то булева переменная
На Kotlin в виде отдельной функции.
private fun getScreenSizeCategory(): String < return when (resources.configuration.screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK) < Configuration.SCREENLAYOUT_SIZE_XLARGE ->"XLarge screen" Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large screen" Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal size screen" Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small size screen" Configuration.SCREENLAYOUT_SIZE_UNDEFINED -> "Undefined screen size" else -> "Error" > >
private final float LOW_LEVEL = 0.75f; private final float MEDIUM_LEVEL = 1.0f; private final float HIGH_LEVEL = 1.5f; float level = getApplicationContext().getResources().getDisplayMetrics().density; if(level == LOW_LEVEL)< //do something here >else if(level == MEDIUM_LEVEL)< //do smoothing here >else if(level == HIGH_LEVEL) < //do something here >
Заглянув в документацию, обнаружил, что можно обойтись без собственных констант. Они уже есть в Android. Оформил в виде отдельного метода.
private void getDeviceDensity() < int dpiDensity = getResources().getDisplayMetrics().densityDpi; switch(dpiDensity)< case DisplayMetrics.DENSITY_LOW: Log.i("Density", "DENSITY_LOW"); break; case DisplayMetrics.DENSITY_MEDIUM: Log.i("Density", "DENSITY_MEDIUM"); break; case DisplayMetrics.DENSITY_HIGH: Log.i("Density", "DENSITY_HIGH"); break; case DisplayMetrics.DENSITY_XHIGH: Log.i("Density", "DENSITY_XHIGH"); break; case DisplayMetrics.DENSITY_XXHIGH: Log.i("Density", "DENSITY_XXHIGH"); break; case DisplayMetrics.DENSITY_XXXHIGH: Log.i("Density", "DENSITY_XXXHIGH"); break; >>
Получить текущее значение яркости экрана
В настройках экрана можно установить желаемую яркость экрана при помощи ползунка, но при этом мы не знаем, сколько это в попугаях. Я открою вам секрет при помощи простого кода:
// Kotlin try < val curBrightnessValue = Settings.System.getInt( contentResolver, Settings.System.SCREEN_BRIGHTNESS ) Log.i("Screen", "Текущая яркость экрана: $curBrightnessValue") >catch (e: SettingNotFoundException) < e.printStackTrace() >
// Java // получаем текущее значение яркости при нажатии на кнопку public void onClick(View v) < TextView infoTextView = findViewById(R.id.textViewInfo); try < int curBrightnessValue = android.provider.Settings.System.getInt( getContentResolver(), android.provider.Settings.System.SCREEN_BRIGHTNESS); infoTextView.setText("Текущая яркость экрана: " + curBrightnessValue); >catch (SettingNotFoundException e) < e.printStackTrace(); >>
Установить яркость экрана
Если можно получить значение текущей яркости экрана, значит можно и установить яркость. Для начала нужно установить разрешение на изменение настроек в манифесте:
Для настройки яркости нужно использовать параметр System.SCREEN_BRIGHTNESS. Добавим на форму кнопку, метку и ползунок. Код для установки яркости:
private float mBackLightValue = 0.5f; // значение по умолчанию @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); SeekBar backLightSeekBar = findViewById(R.id.seekBar); final TextView settingTextView = findViewById(R.id.textViewSetting); Button updateButton = findViewById(R.id.buttonUpdate); updateButton.setOnClickListener(new Button.OnClickListener() < @Override public void onClick(View view) < int sysBackLightValue = (int) (mBackLightValue * 255); android.provider.Settings.System.putInt(getContentResolver(), android.provider.Settings.System.SCREEN_BRIGHTNESS, sysBackLightValue); >>); backLightSeekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() < @Override public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) < mBackLightValue = (float) progress / 100; settingTextView.setText(String.valueOf(mBackLightValue)); WindowManager.LayoutParams layoutParams = getWindow().getAttributes(); layoutParams.screenBrightness = mBackLightValue; getWindow().setAttributes(layoutParams); >@Override public void onStartTrackingTouch(SeekBar seekBar) < >@Override public void onStopTrackingTouch(SeekBar seekBar) < >>); >
Проверил старый пример времён Android 2.2 на эмуляторе с Android 10. Правила ужесточились. Теперь разрешение на изменение системных настроек выдаются только системным программам. Пока ещё есть лазейка, которой и воспользуемся. Новый пример написан на Kotlin. Добавим в манифест немного модифицированное разрешение.
Далее программа должна проверить возможность изменять системные настройки через метод canWrite(). Если такая возможность есть, то запрашиваем разрешение. Появится специальное окно, в котором пользователь должен подтвердить своё решение через переключатель. После этого нужно заново запустить программу, чтобы ползунок стал доступен. Теперь можете менять настройки.
package ru.alexanderklimov.brightness import android.content.Intent import android.net.Uri import android.os.Bundle import android.provider.Settings import android.widget.SeekBar import androidx.appcompat.app.AppCompatActivity import kotlinx.android.synthetic.main.activity_main.* class MainActivity : AppCompatActivity() < override fun onCreate(savedInstanceState: Bundle?) < super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) val brightness = getBrightness() seekBar.progress = brightness textView.text = "Screen Brightness: $brightness" val canWrite = Settings.System.canWrite(this) // If app has no permission to write system settings if (!canWrite) < seekBar.isEnabled = false allowWritePermission() >seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener < override fun onProgressChanged(seekBar: SeekBar?, progress: Int, fromUser: Boolean) < textView.text = "Screen Brightness : $progress" setBrightness(progress) >override fun onStartTrackingTouch(seekBar: SeekBar) < >override fun onStopTrackingTouch(seekBar: SeekBar) < >>) > private fun allowWritePermission() < val intent = Intent( Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri.parse("package:$packageName") ) startActivity(intent) >private fun getBrightness(): Int < return Settings.System.getInt(contentResolver, Settings.System.SCREEN_BRIGHTNESS, 0) >fun setBrightness(value: Int) < Settings.System.putInt( this.contentResolver, Settings.System.SCREEN_BRIGHTNESS, value ) >>
Настраиваем яркость экрана в своём приложении
Существует возможность переопределить яркость экрана в пределах своего приложения. Я не смог придумать, где можно найти практическое применение, но вдруг вам пригодится. Для управления яркостью экрана воспользуемся элементом SeekBar.
За яркость экрана отвечает свойство LayoutParams.screenBrightness:
package ru.alexanderklimov.screen; import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.view.WindowManager; import android.widget.SeekBar; import android.widget.TextView; public class MainActivity extends AppCompatActivity < @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); SeekBar backLightSeekBar = findViewById(R.id.seekBar); final TextView settingTextView = findViewById(R.id.textViewSetting); backLightSeekBar .setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() < @Override public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) < float backLightValue = (float) progress / 100; settingTextView.setText(String.valueOf(backLightValue)); WindowManager.LayoutParams layoutParams = getWindow() .getAttributes(); layoutParams.screenBrightness = backLightValue; getWindow().setAttributes(layoutParams); >@Override public void onStartTrackingTouch(SeekBar seekBar) < >@Override public void onStopTrackingTouch(SeekBar seekBar) < >>); > >
Интересно, что когда выводил ползунок в значение 0, то эмулятор зависал с экраном блокировки. Вам следует учесть эту ситуацию и добавить условие:
if(backLightValue
Опять столкнулся с проблемой. Пример работал на старых устройствах, а на некоторых устройства не работает. Но за эти годы мне ни разу не пришлось использовать этот способ, поэтому даже не стал искать причину. И кстати, ошибка со значением 0 уже не возникает (возможно из-за того, что сам пример не работает как раньше).
Определение поддерживаемых экранных размеров в манифесте
Не всегда предоставляется возможным написать приложение для всех возможных типов экранов. Вы можете использовать тег в манифесте, чтобы указать, на устройствах с какими экранами может работать ваша программа.
В данном примере приводится поддержка нормальных и больших экранов. Маленьким экраном можно назвать любой дисплей с разрешением меньше, чем HVGA. Под большим экраном подразумевается такой, который значительно больше, чем у смартфона (например, у планшетов). Экран нормальных размеров имеет большинство смартфонов.
Атрибут anyDensity говорит о том, каким образом ваше приложение будет масштабироваться при отображении на устройствах с разной плотностью пикселов. Если вы учитываете это свойство экрана в своем интерфейсе, установите этому атрибуту значение true. При значении false Android будет использовать режим совместимости, пытаясь корректно масштабировать пользовательский интерфейс приложения. Как правило, это снижает качество изображения и приводит к артефактам при масштабировании. Для приложений, собранных с помощью SDK с API level 4 и выше, этот атрибут по умолчанию имеет значение true.
Размеры картинок для фона экрана
Если вы используете изображение в качестве фона, то нет смысла выводить очень большую картинку на устройстве с маленьким экраном. Можно подготовить разные размеры.
res/drawable-ldpi — 240×320
res/drawable-mdpi — 320×480
res/drawable-hdpi — 480×800
res/drawable-xhdpi — 640×960
res/drawable-xxhdpi — 960×1440
res/drawable-tvdpi — 1.33 * mdpi
Как на java определить ширину и высоту экрана телефона?
В книге Дейтелов по разработке на андроиде (третье издание) я встретил такой пример:
// Определение размера экрана
int screenSize = getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK; Правда это размер по специальной шкале класса Configuration: в диапазоне [1; 4], чему соответствуют константы с наименованиями: SCREENLAYOUT_SIZE_SMALL, SCREENLAYOUT_SIZE_NORMAL, SCREENLAYOUT_SIZE_LARGE и SCREENLAYOUT_SIZE_XLARGE. Соответственно, это позволяет компактно использовать результат в логических выражениях, например так:
mUsedTwoFragmentLayout = screenSize == 4;
Это не совсем то, что вам нужно, но я думаю, это будет полезно.
Как узнать разрешение экрана телефона
Разрешением экрана смартфона принято называть величину, определяющую количество точек на единицу площади. Говоря простыми словами, разрешение экрана – это соотношение ширины и высоты дисплея смартфона. Раньше практически все смартфоны производились со стандартными показателями разрешения дисплеев – 1920х1080, 1280х720 пикселей и т.д. А сейчас выпускается огромное разнообразие моделей смартфонов с различными разрешениями. В сегодняшней статье поговорим о том, как определить разрешение экрана своего телефонного устройства:
Простой способ узнать разрешение экрана
Способ №1 Официальный сайт
Проще всего узнать точные показатели разрешения своего смартфона, посетив официальный сайт производителя. Для этого нужно ввести в поисковую строку любого поисковика следующую фразу: “LG K8 официальный сайт” (вместо “LG K8” укажите название модели своего смартфона). Поисковик выдаст список сайтов, среди которых необходимый сайт будет присутствовать в числе первых.
Там можно будет ознакомиться со всеми характеристиками своего устройства. Также производители часто указывают разрешение экрана и на упаковке от телефона или же в инструкции по использованию. Если по каким-либо причинам инструкция и упаковка от смартфона не сохранились, а посещать сайт производителя нет желания, то переходим к следующему способу.
Способ №2 Скриншот
Данный способ подходит для любых моделей смартфонов. Рассмотрим пример на смартфоне LG K8:
• Сделайте скриншот экрана. Практически на всех моделях смартфонов скриншот делается путем одновременного нажатия сразу двух клавиш: клавиша уменьшения громкости звука + кнопка выключения.
• Сделав скриншот, найдите его в галерее и вызовите контекстное меню. Чаще всего контекстное меню вызывается посредством длительного нажатия на изображение.
• Перейдите в раздел “Сведения”, в котором и будут присутствовать показатели разрешения.
К сожалению, данный способ не совсем точный. Это объясняется тем, что разрешение экрана можно менять в настройках, поэтому в случае с указанным примером можно будет определить только тот показатель разрешения, который установлен в настройках на данный момент. Также стоит отметить, что на некоторых моделях смартфонов указанное в характеристиках максимальное разрешение экрана становится доступным лишь в определенных условиях.
В заключение стоит упомянуть еще об одном способе. В некоторых моделях смартфонов параметры разрешения экрана можно отыскать в разделе общих настроек, который обычно называется “Экран” или ”Дисплей”.
Разрешение экрана
Просто скопируйте удобный для вас вариант, чтобы вставить на форум, соцсети, мессенджер и поделиться полезной страницей с друзьями.
Ссылка на страницу
Разрешение экрана в пикселях:
Ширина физическая: , логическая: Высота физическая: , логическая: Пикселей физически: , логически:
Разрешение экрана браузера в пикселях:
Ширина: Высота: Всего пикселей:
Дополнительно:
DPR (Device Pixel Ratio): Глубина цвета: бит Операционная система: Браузер: User agent заголовок:
Разрешение экрана монитора ноутбука или компьютера — это количество отдельных пикселей по оси X и оси Y, которые могут быть отображены. Указывается в формате ширина x высота, например, 1920 x 1080 пикселей.
Чем выше разрешение, тем более чётко и ясно отображается весь контент, кроме того, можно разместить больше контента. С другой стороны, чрезмерно высокое значение при небольшой диагонали будет отображать содержимое слишком мелким, что потребует от пользователя включить масштабирование.
Наш сайт может определить разрешение экрана онлайн, глубину цвета, а так же значение DPR.
Что такое Device Pixel Ratio?
Это значение, от которого зависит отображение контента. Представляет из себя отношение физического разрешения к логическому разрешению. К примеру, дисплей моего смартфона определяется в браузере, как 393х851 px и 2.75 DPR, что равно физическому разрешению 2340×1080 px при диагонали 6.67″. Давайте разберёмся, для чего так сделано.
Во времена посредственных и зернистых дисплеев у смартфонов, говоря о пикселе мы представляли себе квадрат размером 1х1. Легко, быстро и логично. Сейчас точно так же происходит, если мы говорим о физическом разрешении экрана, исключая Pentile.
В 2010 году компания Apple представляет Retina и, на экранах с повышенной плотностью пикселей, начинает использоваться логическое разрешение, где координаты обозначаются абстрактными точками (point). Во время отрисовки изображения происходит растеризация. Координаты точки умножаются на масштабный коэффициент и получаются координаты пикселя. Чем выше коэффициент — тем выше детализация. Каждая точка — это квадрат, состоящий из физических пикселей, например:
@x1 — сторона 1×1 пиксель, всего 1 пиксель.
@x2 — сторона 2×2 пикселя для 4 пикселей
@x3 — сторона 3×3 пикселя, всего 9 пикселей.
Реальные примеры от Apple
IPhone 11:
Логическое: 414×896 px.
Коэффициент: x2
Физическое = 828×1792 px.
iPhone 11 Pro:
Логическое: 375×812 px.
Коэффициент: x3
Физическое = 1125×2436 px.
Что насчёт Android?
Google разработала свою собственную систему измерения под названием Density-independent pixels (dp или dip). Независимые от плотности пиксели — это тоже абстрактная единица, за основу которой взят дисплей с разрешением 160 точек на дюйм.
После экскурса в историю, перейдём к практике. Как я уже упоминал, в моём Android установлена матрица 2340×1080 пикселей с диагональю 6.67″. Перемножаем и получаем 2 527 200 пикселей всего, на диагонали 6.67″. Для сравнения, компьютерный монитор с разрешением 1920×1080 и диагональю 27″ имеет 2 073 600 пикселей.
Начинаете понимать, в чём дело? У маленького экрана телефона пикселей больше, чем у большого монитора. Очевидно, что размер каждого отдельно взятого пикселя у смартфона будет заметно меньше, чем у монитора. Подробно прочитать и рассчитать количество пикселей на дюйм вы можете по ссылке калькулятор PPI. Итак, если мы хотим нарисовать линию толщиной в один пиксель, на компьютере она окажется заметно толще, чем на телефоне. И текст, хорошо читаемый на одном устройстве, окажется нечитабельным на другом.
Поэтому нам на помощь приходят вышеупомянутые ухищрения производителей и телефон рисует не едва различимую линию толщиной 1 пикс, а нормально видимую с толщиной почти в 3 раза больше.
Самые популярные разрешения
Компьютерных мониторов и ноутбуков и их маркетинговые названия:
- 1280×720 (720p, HD, HD Ready, Standard HD)
- 1920×1080 (1080p, Full HD, FHD)
- 256 x1440 (1440p, Wide Quad HD, Quad HD, WQHD, QHD)
- 3840×2160 (4K, Ultra HD, UHD, 4K UHD)
- 7680×4320 (8K, 8K UHD).
Самые популярные у смартфонов и планшетов, Здесь вы можете удивиться значениям, но вспомните о Device Pixel Ratio, физически пикселей больше, чем указано логических в списке.
- 360×800
- 414х896
- 360х640
- 390х844
- 412х915
- 360х780
Соотношение сторон
Соотношение ширины и высоты, screen aspect ratio. Зайдите сюда, чтобы узнать подробнее.
Донат
Если страница оказалась для вас полезной, можете поблагодарить автора. Получить искреннее спасибо от незнакомых людей всегда очень приятно, даже если это символическая сумма.