在Android中获取屏幕宽度和高度_Android

在Android中获取屏幕宽度和高度

android

在Android中获取屏幕宽度和高度,android,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()); }

如何获取屏幕宽度和高度，并在以下情况下使用此值：

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

只需更新parag和SpK的答案，以与不推荐使用的方法的当前SDK向后兼容性保持一致：

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

请尝试以下代码：-

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

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

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

metrics.heightPixels;
metrics.widthPixels;

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

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

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

metrics.heightPixels;
metrics.widthPixels;

或

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

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

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

metrics.heightPixels;
metrics.widthPixels;

为什么不呢

DisplayMetrics DisplayMetrics=getResources（）.getDisplayMetrics（）

然后使用

displayMetrics.widthPixels（高度像素）

此处显示的方法已弃用/过时，但仍然有效。需要API 13

看看

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

获取屏幕宽度和高度的值

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

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

只需使用下面的函数，它以整数数组的形式返回屏幕大小的宽度和高度

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

以完整方式执行，返回真正的解决方案：

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

由于这可能会在不同的方向上发生变化，这里有一个解决方案（在Kotlin中），无论方向如何，都可以使其正确：

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

[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

/**
*返回设备的自然方向：Configuration.orientation\u横向或Configuration.orientation\u纵向。


*无论设备的方向如何，结果都应一致
*/
@JvmStatic
有趣的getScreenNaturalOrientation（上下文：context）：Int{
//基于：http://stackoverflow.com/a/9888357/878126
val windowManager=context.getSystemService（context.WINDOW\u服务）作为windowManager
val config=context.resources.configuration
val rotation=windowManager.defaultDisplay.rotation
返回if（（rotation==Surface.rotation|u 0 | rotation==Surface.rotation_180）和&config.orientation==Configuration.orientation_横向|（rotation==Surface.rotation_90 | rotation==Surface.rotation_270）和&config.orientation==Configuration.orientation_纵向）
配置.方向/景观
其他的
配置.方向图
}
/**
*返回自然屏幕大小（以像素为单位）。无论设备的方向如何，结果都应一致
*/
@JvmStatic
趣味getScreenNaturalSize（上下文：上下文）：要点{
val screenNaturalOrientation=getScreenNaturalOrientation（上下文）
val wm=context.getSystemService（context.WINDOW\u服务）作为WindowManager
val点=点（）
wm.defaultDisplay.getRealSize（点）
val currentOrientation=context.resources.configuration.orientation
如果（currentOrientation==ScreenNaturaloRitation）
返回点
else返回点（点y、点x）
}

我在本页找到了魏根的最佳答案，以下是你如何在Xamarin.Android中使用它：

public int GetScreenWidth()
{
    return Resources.System.DisplayMetrics.WidthPixels;
}

public int GetScreenHeight()
{
    return Resources.System.DisplayMetrics.HeightPixels;
}

屏幕分辨率是屏幕中像素的总数。以下程序将提取设备的屏幕分辨率。它将打印屏幕宽度和高度。这些值以像素为单位

public static Point getScreenResolution(Context context) {
// get window managers
WindowManager manager =  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Display display = manager.getDefaultDisplay();
Point point = new Point();
display.getSize(point);

 // get width and height
 int width = point.x;
 int height = point.y;

 return point;

}

这将与Android中的大小抽象配合使用

它包含一个类您可以这样使用它：

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();

两步。首先，扩展活动类

class Example extends Activity

第二：使用这个代码

 DisplayMetrics displayMetrics = new DisplayMetrics();
 WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
 windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
 int deviceWidth = displayMetrics.widthPixels;
 int deviceHeight = displayMetrics.heightPixels;

请为Kotlin尝试此代码

 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y

    val width: Int = context.resources.displayMetrics.widthPixels
    val height: Int = context.resources.displayMetrics.heightPixels

这里没有一个答案适用于Chrome操作系统的多显示器或即将推出的可折叠显示器

查找当前配置时，请始终使用

getResources（）.getConfiguration（）

中当前活动中的配置请勿使用后台活动或系统资源中的配置。后台活动没有大小，系统配置可能包含多个大小和方向冲突的窗口，因此无法提取可用数据
所以答案是

val config = context.getResources().getConfiguration() val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp
对于kotlin用户的

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 }

使用Android非常容易：

int width = Resources.getSystem().getDisplayMetrics().widthPixels; int height = Resources.getSystem().getDisplayMetrics().heightPixels;

我使用以下代码获得屏幕尺寸

getWindow().getDecorView().getWidth() getWindow().getDecorView().getHeight()
我更新了Kotlin语言的答案
对于Kotlin：您应该调用窗口管理器并获取度量。在那简单的方法之后

val displayMetrics = DisplayMetrics() windowManager.defaultDisplay.getMetrics(displayMetrics) var width = displayMetrics.widthPixels var height = displayMetrics.heightPixels
我们如何用Kotlin语言以独立活动的方式有效地使用它
在这里，我在general Kotlin类中创建了一个方法。您可以在所有活动中使用它

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 } }
在某些情况下，这可能不起作用。对于：
获取描述此文件大小和密度的显示度量展示。此方法返回的大小不一定表示显示器的实际原始大小（本机分辨率）

可以调整返回的大小，以排除始终可见的某些系统装饰元素

可以对其进行缩放，以提供与最初为较小显示器设计的旧应用程序的兼容性

根据显示器所属的WindowManager，它可能会有所不同

如果从非活动上下文（例如通过（WindowManager）的应用程序上下文）请求 getApplicationContext（）.getSystemService（Context.WINDOW\u服务）） metrics将根据当前数据报告整个显示的大小旋转和减去系统装饰区域

如果从活动（使用getWindowManager（）或（WindowManager）getSystemService（Context.WINDOW_服务）请求）生成指标将与当前应用程序窗口指标相对应。在这种情况下，大小可以小于多窗口模式下的物理大小

所以，为了
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

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

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

@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR1) public static double getHeight() { DisplayMetrics displayMetrics = new DisplayMetrics(); WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); Display display = wm.getDefaultDisplay(); display.getRealMetrics(displayMetrics); //int height = displayMetrics.heightPixels; //int width = displayMetrics.widthPixels; return displayMetrics.heightPixels; }

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