반응형
Android에서 화면 너비 및 높이 가져오기
화면 너비 및 높이를 가져오고 이 값을 사용하는 방법은 다음과 같습니다.
@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
Log.e(TAG, "onMeasure" + widthSpecId);
setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT -
game.findViewById(R.id.flag).getHeight());
}
이 코드를 사용하면 런타임 디스플레이의 너비와 높이를 얻을 수 있습니다.
DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;
보기에서 다음과 같은 작업을 수행해야 합니다.
((Activity) getContext()).getWindowManager()
.getDefaultDisplay()
.getMetrics(displayMetrics);
장치에 탐색 모음이 있는 일부 시나리오에서는 런타임에 확인해야 합니다.
public boolean showNavigationBar(Resources resources)
{
int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
return id > 0 && resources.getBoolean(id);
}
장치에 탐색 모음이 있는 경우 높이를 계산합니다.
private int getNavigationBarHeight() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int usableHeight = metrics.heightPixels;
getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
int realHeight = metrics.heightPixels;
if (realHeight > usableHeight)
return realHeight - usableHeight;
else
return 0;
}
return 0;
}
따라서 장치의 최종 높이는 다음과 같습니다.
int height = displayMetrics.heightPixels + getNavigationBarHeight();
매우 간단한 답변과 패스 컨텍스트가 없습니다.
public static int getScreenWidth() {
return Resources.getSystem().getDisplayMetrics().widthPixels;
}
public static int getScreenHeight() {
return Resources.getSystem().getDisplayMetrics().heightPixels;
}
참고: 높이에 탐색 막대를 포함하려면 아래 방법을 사용합니다.
WindowManager windowManager =
(WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
final Display display = windowManager.getDefaultDisplay();
Point outPoint = new Point();
if (Build.VERSION.SDK_INT >= 19) {
// include navigation bar
display.getRealSize(outPoint);
} else {
// exclude navigation bar
display.getSize(outPoint);
}
if (outPoint.y > outPoint.x) {
mRealSizeHeight = outPoint.y;
mRealSizeWidth = outPoint.x;
} else {
mRealSizeHeight = outPoint.x;
mRealSizeWidth = outPoint.y;
}
사용되지 않는 방법에서 현재 SDK 하위 호환성에 맞게 패러그 및 SpK로 답변을 업데이트하기만 하면 됩니다.
int Measuredwidth = 0;
int Measuredheight = 0;
Point size = new Point();
WindowManager w = getWindowManager();
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
w.getDefaultDisplay().getSize(size);
Measuredwidth = size.x;
Measuredheight = size.y;
}else{
Display d = w.getDefaultDisplay();
Measuredwidth = d.getWidth();
Measuredheight = d.getHeight();
}
그거 좋지
DisplayMetrics displaymetrics = getResources().getDisplayMetrics();
사용할 경우
displayMetrics.widthPixels
그리고.
displayMetrics.heightPixels
Android에서는 매우 쉽게 사용할 수 있습니다.
int width = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;
컨텍스트에서 너비와 높이를 얻을 수 있습니다.
java:
int width= context.getResources().getDisplayMetrics().widthPixels;
int height= context.getResources().getDisplayMetrics().heightPixels;
코틀린
val width: Int = context.resources.displayMetrics.widthPixels
val height: Int = context.resources.displayMetrics.heightPixels
•Kotlin Version경유로Extension Property
화면 크기를 픽셀 단위로 알고 싶은 경우에 따라dp이러한 확장 속성을 사용하면 다음과 같은 이점이 있습니다.
DimensionUtils.kt
import android.content.Context
import android.content.res.Resources
import android.graphics.Rect
import android.graphics.RectF
import android.os.Build
import android.util.DisplayMetrics
import android.view.WindowManager
import kotlin.math.roundToInt
/**
* @author aminography
*/
private val displayMetrics: DisplayMetrics by lazy { Resources.getSystem().displayMetrics }
/**
* Returns boundary of the screen in pixels (px).
*/
val screenRectPx: Rect
get() = displayMetrics.run { Rect(0, 0, widthPixels, heightPixels) }
/**
* Returns boundary of the screen in density independent pixels (dp).
*/
val screenRectDp: RectF
get() = screenRectPx.run { RectF(0f, 0f, right.px2dp, bottom.px2dp) }
/**
* Returns boundary of the physical screen including system decor elements (if any) like navigation
* bar in pixels (px).
*/
val Context.physicalScreenRectPx: Rect
get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
(applicationContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager)
.run { DisplayMetrics().also { defaultDisplay.getRealMetrics(it) } }
.run { Rect(0, 0, widthPixels, heightPixels) }
} else screenRectPx
/**
* Returns boundary of the physical screen including system decor elements (if any) like navigation
* bar in density independent pixels (dp).
*/
val Context.physicalScreenRectDp: RectF
get() = physicalScreenRectPx.run { RectF(0f, 0f, right.px2dp, bottom.px2dp) }
/**
* Converts any given number from pixels (px) into density independent pixels (dp).
*/
val Number.px2dp: Float
get() = this.toFloat() / displayMetrics.density
/**
* Converts any given number from density independent pixels (dp) into pixels (px).
*/
val Number.dp2px: Int
get() = (this.toFloat() * displayMetrics.density).roundToInt()
용도:
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val widthPx = screenRectPx.width()
val heightPx = screenRectPx.height()
println("[PX] screen width: $widthPx , height: $heightPx")
val widthDp = screenRectDp.width()
val heightDp = screenRectDp.height()
println("[DP] screen width: $widthDp , height: $heightDp")
println()
val physicalWidthPx = physicalScreenRectPx.width()
val physicalHeightPx = physicalScreenRectPx.height()
println("[PX] physical screen width: $physicalWidthPx , height: $physicalHeightPx")
val physicalWidthDp = physicalScreenRectDp.width()
val physicalHeightDp = physicalScreenRectDp.height()
println("[DP] physical screen width: $physicalWidthDp , height: $physicalHeightDp")
}
}
결과:
장치가 방향에 있을 때:
[PX] screen width: 1440 , height: 2392
[DP] screen width: 360.0 , height: 598.0
[PX] physical screen width: 1440 , height: 2560
[DP] physical screen width: 360.0 , height: 640.0
장치가 방향에 있을 때:
[PX] screen width: 2392 , height: 1440
[DP] screen width: 598.0 , height: 360.0
[PX] physical screen width: 2560 , height: 1440
[DP] physical screen width: 640.0 , height: 360.0
아래 코드를 사용해 보십시오.
1.
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;
2.
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth(); // deprecated
int height = display.getHeight(); // deprecated
또는
int width = getWindowManager().getDefaultDisplay().getWidth();
int height = getWindowManager().getDefaultDisplay().getHeight();
3.
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
metrics.heightPixels;
metrics.widthPixels;
화면 크기 검색에 적용 가능한 일부 방법은 API 레벨 31에서 더 이상 사용되지 않습니다.Display.getRealMetrics()그리고.Display.getRealSize()API 레벨 30부터 사용할 수 있습니다.WindowManager#getCurrentWindowMetrics()화면 크기를 가져오는 가장 쉬운 방법은 다음과 같은 일부 Compat 클래스를 만드는 것입니다.
object ScreenMetricsCompat {
private val api: Api =
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) ApiLevel30()
else Api()
/**
* Returns screen size in pixels.
*/
fun getScreenSize(context: Context): Size = api.getScreenSize(context)
@Suppress("DEPRECATION")
private open class Api {
open fun getScreenSize(context: Context): Size {
val display = context.getSystemService(WindowManager::class.java).defaultDisplay
val metrics = if (display != null) {
DisplayMetrics().also { display.getRealMetrics(it) }
} else {
Resources.getSystem().displayMetrics
}
return Size(metrics.widthPixels, metrics.heightPixels)
}
}
@RequiresApi(Build.VERSION_CODES.R)
private class ApiLevel30 : Api() {
override fun getScreenSize(context: Context): Size {
val metrics: WindowMetrics = context.getSystemService(WindowManager::class.java).currentWindowMetrics
return Size(metrics.bounds.width(), metrics.bounds.height())
}
}
}
하기 르기ScreenMetricsCompat.getScreenSize(this).heightActivity화면 높이를 얻을 수 있습니다.
확장 기능을 만드는 것이 좋습니다.
/**
* Return the width and height of the screen
*/
val Context.screenWidth: Int
get() = resources.displayMetrics.widthPixels
val Context.screenHeight: Int
get() = resources.displayMetrics.heightPixels
/**
* Pixel and Dp Conversion
*/
val Float.toPx get() = this * Resources.getSystem().displayMetrics.density
val Float.toDp get() = this / Resources.getSystem().displayMetrics.density
val Int.toPx get() = (this * Resources.getSystem().displayMetrics.density).toInt()
val Int.toDp get() = (this / Resources.getSystem().displayMetrics.density).toInt()
DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;
코틀린 사용자용
fun Activity.displayMetrics(): DisplayMetrics {
val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
return displayMetrics
}
그리고 활동에서는 다음과 같이 사용할 수 있습니다.
resources.displayMetrics.let { displayMetrics ->
val height = displayMetrics.heightPixels
val width = displayMetrics.widthPixels
}
또는 단편적으로
activity?.displayMetrics()?.run {
val height = heightPixels
val width = widthPixels
}
getMetrics 및 getRealMetrics는 더 이상 사용되지 않으므로 다음과 같이 화면 너비와 높이를 결정하는 것이 좋습니다.
WindowMetrics windowMetrics = getActivity().getWindowManager().getMaximumWindowMetrics();
Rect bounds = windowMetrics.getBounds();
int widthPixels = bounds.width();
int heightPixels = bounds.height();
하지만 같은 결과를 얻을 수 있는 또 다른 방법을 알아냈습니다.
Configuration configuration = mContext.getResources().getConfiguration();
Display.Mode mode = display.getMode();
int widthPixels = mode.getPhysicalWidth();
int heightPixels = mode.getPhysicalHeight();
여기에 나와 있는 답 중 크롬 OS 다중 디스플레이 또는 곧 출시될 Foldable에 대해 제대로 작동하는 답이 없습니다.
활동의 구성을 사용하십시오.
getResources().getConfiguration()백그라운드 작업의 구성이나 시스템 리소스의 구성을 사용하지 마십시오.백그라운드 작업에 크기가 없으며, 시스템 구성에 크기와 방향이 충돌하는 여러 창이 포함될 수 있으므로 사용 가능한 데이터를 추출할 수 없습니다.
그래서 답은.
val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int width = dimension.widthPixels;
int height = dimension.heightPixels;
Android 공식 문서에 따르면 기본 디스플레이에 대해 Context#getDisplay()를 사용합니다. 이 방법은 API 레벨 30에서 더 이상 사용되지 않기 때문입니다.
윈도우즈 관리자()를 가져옵니다.
기본 화면표시 가져오기().메트릭 가져오기(측정지표 표시);
아래에 제시된 코드는 코틀린으로 되어 있으며 Android의 최신 버전에 따라 작성되어 폭과 높이를 결정하는 데 도움이 됩니다.
fun getWidth(context: Context): Int {
var width:Int = 0
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
val displayMetrics = DisplayMetrics()
val display: Display? = context.getDisplay()
display!!.getRealMetrics(displayMetrics)
return displayMetrics.widthPixels
}else{
val displayMetrics = DisplayMetrics()
this.windowManager.defaultDisplay.getMetrics(displayMetrics)
width = displayMetrics.widthPixels
return width
}
}
fun getHeight(context: Context): Int {
var height: Int = 0
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
val displayMetrics = DisplayMetrics()
val display = context.display
display!!.getRealMetrics(displayMetrics)
return displayMetrics.heightPixels
}else {
val displayMetrics = DisplayMetrics()
this.windowManager.defaultDisplay.getMetrics(displayMetrics)
height = displayMetrics.heightPixels
return height
}
}
fun Activity.getRealScreenSize(): Pair<Int, Int> { //<width, height>
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
val size = Point()
display?.getRealSize(size)
Pair(size.x, size.y)
} else {
val size = Point()
windowManager.defaultDisplay.getRealSize(size)
Pair(size.x, size.y)
}}
이 기능은 확장 기능이며 다음과 같은 방법으로 활동에 사용할 수 있습니다.
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val pair = getRealScreenSize()
pair.first //to get width
pair.second //to get height
}
사용자가 해상도를 변경한 경우를 포함하여 실제 해상도를 반환하는 전체 방법은 "getRealSize"를 사용하는 것입니다.
문서에서 이 기능 대신 사용하라고 하는 기능을 포함하여 사용 가능한 다른 모든 기능은 결과가 더 작은 경우가 있다는 것을 알게 되었습니다.
이를 위한 코드는 다음과 같습니다.
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Point size = new Point();
wm.getDefaultDisplay().getRealSize(size);
final int width = size.x, height = size.y;
그리고 이것은 다른 방향으로 바뀔 수 있기 때문에 (코틀린에 있는) 솔루션은 방향에 상관없이 올바르게 적용할 수 있습니다.
/**
* returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
* The result should be consistent no matter the orientation of the device
*/
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
//based on : http://stackoverflow.com/a/9888357/878126
val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
val config = context.resources.configuration
val rotation = windowManager.defaultDisplay.rotation
return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
Configuration.ORIENTATION_LANDSCAPE
else
Configuration.ORIENTATION_PORTRAIT
}
/**
* returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
*/
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
val screenNaturalOrientation = getScreenNaturalOrientation(context)
val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
val point = Point()
wm.defaultDisplay.getRealSize(point)
val currentOrientation = context.resources.configuration.orientation
if (currentOrientation == screenNaturalOrientation)
return point
else return Point(point.y, point.x)
}
화면 너비 및 높이 값을 가져옵니다.
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
width = size.x;
height = size.y;
Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();
public class DisplayInfo {
int screen_height=0, screen_width=0;
WindowManager wm;
DisplayMetrics displaymetrics;
DisplayInfo(Context context) {
getdisplayheightWidth(context);
}
void getdisplayheightWidth(Context context) {
wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
displaymetrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(displaymetrics);
screen_height = displaymetrics.heightPixels;
screen_width = displaymetrics.widthPixels;
}
public int getScreen_height() {
return screen_height;
}
public int getScreen_width() {
return screen_width;
}
}
다음 코드를 사용하여 화면 치수를 가져옵니다.
getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()
Android 11이 탑재된 갤럭시 M51의 경우 이 모든 답변이 실패하는 것 같습니다.몇 가지 조사를 한 후에 다음 코드를 참조하십시오.
WindowMetrics windowmetrics = MainActivity.getWindowManager().getCurrentWindowMetrics();
Rect rect = windowmetrics.getBounds();
int width = rect.right;
int height =rect.bottom;
에는 실제 장치 해상도인 1080x2400이 표시되고, 나머지는 810x1200만 반환됩니다.
위의 많은 버전을 시도한 후, 저는 코틀린에서 답을 찾았습니다.장치에 대해 보급된 해상도를 정확하게 반환합니다.오래된 장치에서 작동하지 않는 경우 알려 주십시오. 현재 비교적 새 장치만 있습니다.
이 솔루션은 사용되지 않는 기능을 사용하지 않습니다(2023년 1월 기준).
private fun getScreenHeight() : Int {
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
val windowMetrics = windowManager.currentWindowMetrics
val rect = windowMetrics.bounds
rect.bottom
} else {
resources.displayMetrics.heightPixels
}
}
여기에 표시된 메서드는 더 이상 사용되지 않거나 구식이지만 여전히 작동합니다.API 13 필요
이것을 확인해 보세요
Display disp= getWindowManager().getDefaultDisplay();
Point dimensions = new Point();
disp.getSize(size);
int width = size.x;
int height = size.y;
Android 공식 문서에 따르면 기본 디스플레이에 대해 Context#getDisplay()를 사용합니다. 이 방법은 API 레벨 30에서 더 이상 사용되지 않기 때문입니다.
윈도우즈 관리자()를 가져옵니다.
기본 화면표시 가져오기().메트릭 가져오기(측정지표 표시);
이 코드 그릇은 너비와 높이를 결정하는 데 도움이 됩니다.
public static int getWidth(Context context) {
DisplayMetrics displayMetrics = new DisplayMetrics();
Display display = context.getDisplay();
if (display != null) {
display.getRealMetrics(displayMetrics);
return displayMetrics.widthPixels;
}
return -1;
}
높이:
public static int getHeight(Context context) {
DisplayMetrics displayMetrics = new DisplayMetrics();
Display display = context.getDisplay();
if (display != null) {
display.getRealMetrics(displayMetrics);
return displayMetrics.heightPixels;
}
return -1;
}
코틀린에 대해 이 코드를 사용해 보십시오.
val display = windowManager.defaultDisplay
val size = Point()
display.getSize(size)
var DEVICE_WIDTH = size.x
var DEVICE_HEIGHT = size.y
화면 크기의 너비와 높이를 반환하는 아래 함수를 정수 배열로 사용하면 됩니다.
private int[] getScreenSIze(){
DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int h = displaymetrics.heightPixels;
int w = displaymetrics.widthPixels;
int[] size={w,h};
return size;
}
onCreate 기능 또는 버튼에서 다음 코드를 클릭하여 아래와 같이 화면 크기를 출력합니다.
int[] screenSize= getScreenSIze();
int width=screenSize[0];
int height=screenSize[1];
screenSizes.setText("Phone Screen sizes \n\n width = "+width+" \n Height = "+height);
코틀린 언어에 대한 답변을 업데이트했습니다!
코틀린의 경우:Window Manager(윈도우 관리자)에 전화하여 메트릭을 확인해야 합니다.그렇게 쉬운 방법으로.
val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels
어떻게 하면 코틀린 언어로 독립적인 활동 방식으로 효과적으로 사용할 수 있을까요?
여기서 저는 일반적인 코틀린 수업에서 메소드를 만들었습니다.모든 활동에 사용할 수 있습니다.
private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"
private fun getDeviceSizes(activity:Activity, whichSize:String):Int{
val displayMetrics = DisplayMetrics()
activity.windowManager.defaultDisplay.getMetrics(displayMetrics)
return when (whichSize){
T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
else -> 0 // Error
}
}
val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels
언급URL : https://stackoverflow.com/questions/4743116/get-screen-width-and-height-in-android
반응형
'sourcecode' 카테고리의 다른 글
| Mongoose 유효성 검사 오류 처리 - 어디서 어떻게 처리합니까? (0) | 2023.06.03 |
|---|---|
| 가로 세로 비율을 유지하기 위해 ImageView에서 이미지 크기를 조정하는 방법 (0) | 2023.06.03 |
| VB에서 주() 진입점을 찾는 방법.Net winforms 앱? (0) | 2023.06.03 |
| OrderBy와 OrderByDescending은 안정적입니까? (0) | 2023.06.03 |
| Node.js - 플랫폼에 구애받지 않는 방법으로 홈 디렉토리 찾기 (0) | 2023.05.29 |