Obtenir la largeur et la hauteur de l'écran
Comment puis-je obtenir la largeur et la hauteur de l'écran pour utiliser cette valeur dans
@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
Log.e(TAG, "onMeasure" + widthSpecId);
setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT -
game.findViewById(R.id.flag).getHeight());
}
En utilisant ce code, vous pouvez obtenir le runtime Display's Width & Height
DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;
Dans une vue, vous devez faire quelque chose comme ceci:
((Activity) getContext()).getWindowManager()
.getDefaultDisplay()
.getMetrics(displayMetrics);
Il y a une réponse très simple et sans contexte de passe
public static int getScreenWidth() {
return Resources.getSystem().getDisplayMetrics().widthPixels;
}
public static int getScreenHeight() {
return Resources.getSystem().getDisplayMetrics().heightPixels;
}
Remarque: si vous souhaitez que la hauteur inclue la barre de navigation, utilisez la méthode ci-dessous
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;
}
Juste pour mettre à jour la réponse par parag et SpK pour s’aligner sur la compatibilité descendante actuelle du SDK à partir de méthodes obsolètes:
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();
}
Pourquoi pas
DisplayMetrics displaymetrics = getResources (). GetDisplayMetrics ();
puis utiliser
displayMetrics.widthPixels (heightPixels)
Essayez ci-dessous le code: -
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
ou
int width = getWindowManager().getDefaultDisplay().getWidth();
int height = getWindowManager().getDefaultDisplay().getHeight();
3.
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
metrics.heightPixels;
metrics.widthPixels;
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int width = dimension.widthPixels;
int height = dimension.heightPixels;
Obtenir la valeur de la largeur et de la hauteur de l'écran.
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
width = size.x;
height = size.y;
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;
}
}
Les méthodes présentées ici sont obsolètes/obsolètes, mais cela fonctionne toujours.Require API 13
vérifiez-le
Display disp= getWindowManager().getDefaultDisplay();
Point dimensions = new Point();
disp.getSize(size);
int width = size.x;
int height = size.y;
Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();
DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;
Manière complète de le faire, cela retourne la vraie résolution:
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Point size = new Point();
wm.getDefaultDisplay().getRealSize(size);
final int width = size.x, height = size.y;
Et comme cela peut changer d’orientation différente, voici une solution (en Kotlin), pour réussir, peu importe l’orientation:
/**
* 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)
}
Utilisez simplement la fonction ci-dessous qui renvoie la largeur et la hauteur de la taille de l'écran sous forme de tableau d'entiers.
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;
}
Sur votre fonction onCreate ou sur un bouton, ajoutez le code suivant pour afficher les tailles d'écran, comme indiqué ci-dessous
int[] screenSize= getScreenSIze();
int width=screenSize[0];
int height=screenSize[1];
screenSizes.setText("Phone Screen sizes \n\n width = "+width+" \n Height = "+height);
Pour les utilisateurs de kotlin
fun Activity.displayMetrics(): DisplayMetrics {
val displayMetrics = DisplayMetrics();
windowManager.defaultDisplay.getMetrics(displayMetrics);
return displayMetrics
}
Et dans Activity, vous pouvez l'utiliser comme
displayMetrics().let { displayMetrics ->
val height = displayMetrics.heightPixels
val width = displayMetrics.widthPixels
}
Ou en fragment
activity?.displayMetrics()?.run {
val height = heightPixels
val width = widthPixels
}
Deux étapes. Tout d'abord, étendre la classe d'activité
class Example extends Activity
Deuxièmement: Utilisez ce code
DisplayMetrics displayMetrics = new DisplayMetrics();
WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
int deviceWidth = displayMetrics.widthPixels;
int deviceHeight = displayMetrics.heightPixels;
J'ai trouvé la réponse de weigan meilleure dans cette page, voici comment l'utiliser dans Xamarin.Android:
public int GetScreenWidth()
{
return Resources.System.DisplayMetrics.WidthPixels;
}
public int GetScreenHeight()
{
return Resources.System.DisplayMetrics.HeightPixels;
}
Cet ensemble d'utilitaires pour travailler avec l'abstraction de la taille dans Android.
Il contient une classe SizeFromDisplay.Java Vous pouvez l'utiliser comme ceci:
ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();
La résolution de l'écran correspond au nombre total de pixels dans l'écran. Le programme suivant extraira la résolution de l'écran de l'appareil. Il imprimera la largeur et la hauteur de l'écran. Ces valeurs sont en pixel.
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;
}
Essayez ce code pour Kotlin
val display = windowManager.defaultDisplay
val size = Point()
display.getSize(size)
var DEVICE_WIDTH = size.x
var DEVICE_HEIGHT = size.y
int getScreenSize() {
int screenSize = getResources().getConfiguration().screenLayout &
Configuration.SCREENLAYOUT_SIZE_MASK;
// String toastMsg = "Screen size is neither large, normal or small";
Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
int orientation = display.getRotation();
int i = 0;
switch (screenSize) {
case Configuration.SCREENLAYOUT_SIZE_NORMAL:
i = 1;
// toastMsg = "Normal screen";
break;
case Configuration.SCREENLAYOUT_SIZE_SMALL:
i = 1;
// toastMsg = "Normal screen";
break;
case Configuration.SCREENLAYOUT_SIZE_LARGE:
// toastMsg = "Large screen";
if (orientation == Surface.ROTATION_90
|| orientation == Surface.ROTATION_270) {
// TODO: add logic for landscape mode here
i = 2;
} else {
i = 1;
}
break;
case Configuration.SCREENLAYOUT_SIZE_XLARGE:
if (orientation == Surface.ROTATION_90
|| orientation == Surface.ROTATION_270) {
// TODO: add logic for landscape mode here
i = 4;
} else {
i = 3;
}
break;
}
// customeToast(toastMsg);
return i;
}
Aucune des réponses ici ne fonctionne correctement pour les affichages multiples de Chrome OS ou les Foldables à venir.
Lorsque vous recherchez la configuration actuelle, utilisez toujours la configuration de votre activité actuelle dans
getResources().getConfiguration(). N'utilisez pas la configuration de votre activité en arrière-plan ou celle de la ressource système. L'activité en arrière-plan n'a pas de taille et la configuration du système peut contenir plusieurs fenêtres de tailles et d'orientations en conflit , de sorte qu'aucune donnée utilisable ne peut être extraite.
Donc la réponse est
val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp
Il est très facile d’obtenir Android:
int width = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;