Obtenir les dimensions de l'écran en pixels
J'ai créé des éléments personnalisés et je souhaite les placer par programme dans le coin supérieur droit (n pixels du bord supérieur et m pixels du bord droit). Par conséquent, je dois obtenir la largeur et la hauteur de l'écran, puis définir la position:
int px = screenWidth - m;
int py = screenHeight - n;
Comment obtenir screenWidth et screenHeight dans l'activité principale?
Si vous voulez afficher les dimensions en pixels, vous pouvez utiliser getSize :
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;
Si vous n'êtes pas dans une Activity, vous pouvez obtenir la valeur par défaut Display via WINDOW_SERVICE:
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();
Si vous êtes dans un fragment et souhaitez accomplir ceci, utilisez simplement Activity.WindowManager (dans Xamarin.Android) ou getActivity (). GetWindowManager () (en Java).
Avant que getSize ne soit introduit (dans l'API niveau 13), vous pouviez utiliser les méthodes getWidth et getHeight qui sont maintenant obsolètes:
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth(); // deprecated
int height = display.getHeight(); // deprecated
Cependant, pour le cas d'utilisation que vous décrivez, une marge/un remplissage dans la présentation semble plus approprié.
Une autre façon est: DisplayMetrics
Une structure décrivant des informations générales sur un affichage, telles que sa taille, sa densité et la mise à l'échelle des polices. Pour accéder aux membres DisplayMetrics, initialisez un objet comme celui-ci:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
Nous pouvons utiliser widthPixels pour obtenir des informations sur:
"La largeur absolue de l’affichage en pixels."
Exemple:
Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);
Une façon est:
Display display = getWindowManager().getDefaultDisplay();
int width = display.getWidth();
int height = display.getHeight();
Il est obsolète et vous devriez plutôt essayer le code suivant. Les deux premières lignes de code vous donnent les objectifs DisplayMetrics. Cet objet contient les champs tels que heightPixels, widthPixels.
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int width = metrics.widthPixels;
Cela ne répond peut-être pas à votre question, mais il peut être utile de savoir (je le cherchais moi-même quand je suis arrivé à cette question) que si vous avez besoin d'une dimension de View mais que votre code est en cours d'exécution alors que sa mise en page n'a pas encore été affichée (par exemple, dans onCreate()), vous pouvez configurer un ViewTreeObserver.OnGlobalLayoutListener avec View.getViewTreeObserver().addOnGlobalLayoutListener() et y placer le code approprié nécessitant la dimension de la vue. Le rappel de l'auditeur sera appelé lorsque la mise en page aura été aménagée.
(Réponse 2012, peut-être obsolète) Si vous souhaitez prendre en charge pré Honeycomb, vous devez intégrer une compatibilité ascendante avant l'API 13. Quelque chose comme:
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();
}
Bien sûr, les méthodes dépréciées finiront par être retirées des SDK les plus récents, mais, même si la plupart de nos utilisateurs disposent d’Android 2.1, 2.2 et 2.3, c’est ce qui nous reste.
J'ai essayé toutes les "solutions" possibles sans succès et j'ai remarqué que l'application "Dalvik Explorer" d'Elliott Hughes indique toujours la dimension correcte sur toute version de périphérique/OS Android. J'ai fini par regarder son projet open source qui peut être trouvé ici: https://code.google.com/p/enh/
Voici tout le code pertinent:
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) {
}
EDIT: version légèrement améliorée (évite les exceptions de tir sur les versions non supportées du système d'exploitation):
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) {
}
Manière la plus simple:
int screenHeight = getResources().getDisplayMetrics().heightPixels;
int screenWidth = getResources().getDisplayMetrics().widthPixels;
Pour accéder à la hauteur de la barre d'état pour les appareils Android, nous préférons un moyen par programme de l'obtenir:
Exemple de code
int resId = getResources().getIdentifier("status_bar_height", "dimen", "Android");
if (resId > 0) {
result = getResources().getDimensionPixelSize(resId);
}
La variable result donne la hauteur en pixel.
Pour un accès rapide
Pour plus d'informations sur la hauteur de Title bar, Navigation bar et Content View, veuillez consulter Tailles d'écran à l'écran du périphérique Android.
Obtenez d’abord la vue (par exemple, par findViewById()), puis vous pourrez utiliser getWidth () sur la vue elle-même.
J'ai deux fonctions, une pour envoyer le contexte et l'autre pour obtenir la hauteur et la largeur en pixels:
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;
}
et
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;
}
C'est le code que j'utilise pour la tâche:
// `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();
}
Semble assez propre et pourtant, prend en charge la dépréciation.
N'est-ce pas une bien meilleure solution? DisplayMetrics est fourni avec tout ce dont vous avez besoin et fonctionne à partir de l’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;
}
Vous pouvez également obtenir l’affichage réel (y compris les décors d’écran, tels que la barre d’état ou la barre de navigation du logiciel) à l’aide de getRealMetrics , mais cela ne fonctionne que sur 17+.
Est-ce que je manque quelque chose?
Pour une mise à l'échelle dynamique en utilisant XML, il existe un attribut appelé "Android: layout_weight"
L'exemple ci-dessous, modifié à partir de la réponse de synic sur ce fil , montre un bouton occupant 75% de l'écran (poids = .25) et une vue texte occupant les 25% restants de l'écran (poids =. 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>
Trouver la largeur et la hauteur de l'écran:
width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();
En utilisant cela, nous pouvons obtenir le dernier SDK 13 et plus.
// 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);
}
Ajoutant simplement à la réponse de Francesco. L’autre observateur plus apte, si vous souhaitez connaître l’emplacement dans la fenêtre ou l’emplacement à l’écran est ViewTreeObserver.OnPreDrawListener ()
Cela peut également être utilisé pour trouver d'autres attributs d'une vue qui sont pour la plupart inconnus à l'heure de onCreate (), par exemple. la position défilée, la position mise à l'échelle.
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;
Utilisation du code suivant dans Activity.
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
J'ai trouvé que ça faisait l'affaire.
Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);
Faut dire que si vous n'êtes pas dans Activity, mais dans View (ou si vous avez une variable de type View dans votre portée), il n'est pas nécessaire d'utiliser WINDOW_SERVICE. Ensuite, vous pouvez utiliser au moins deux façons.
Premier:
DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();
Seconde:
DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);
Toutes ces méthodes que nous appelons ici ne sont pas obsolètes.
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);
}
}
Pour obtenir les dimensions de l'écran, utilisez les métriques d'affichage.
DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null)
WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display defaultDisplay = windowManager.getDefaultDisplay();
defaultDisplay.getRealMetrics(displayMetrics);
}
Obtenir la hauteur et la largeur en pixels
int width =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;
Ce n'est pas une réponse pour l'OP, car il souhaitait afficher les dimensions en pixels réels. Je voulais les dimensions en "pixels indépendants de l'appareil" et associer des réponses à partir d'ici https://stackoverflow.com/a/17880012/253938 et ici https://stackoverflow.com/a/ 6656774/253938 J'ai imaginé ceci:
DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);
Il existe un moyen non obsolète de faire cela en utilisant DisplayMetrics (API 1), ce qui évite le désordre try/catch:
// 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;
Vous pouvez obtenir le height size en utilisant:
getResources().getDisplayMetrics().heightPixels;
et la width size en utilisant
getResources().getDisplayMetrics().widthPixels;
Je voudrais envelopper le code getSize comme ceci:
@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;
}
Commencez par charger le fichier XML, puis écrivez le code suivant:
setContentView(R.layout.main);
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());
Affichez la largeur et la hauteur en fonction de la résolution de votre écran.
Suivez les méthodes ci-dessous:
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;
}
Pour qui recherche dimension d'écran utilisable sans Barre d'état et Barre d'action (également grâce à 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);
}
Il arrive parfois que vous ayez besoin de connaître les dimensions précises de l'espace disponible pour une mise en page lorsque vous créez une activité ....... Après une réflexion, j'ai élaboré cette méthode.
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();
}
}
}
Si, pour une raison quelconque, vous ne souhaitez pas ajouter une autre activité au manifeste Android, vous pouvez le faire de la manière suivante:
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();
}
}
Si vous ne souhaitez pas surcharger les gestionnaires WindowManagers, Points ou Displays, vous pouvez saisir les attributs height et width de l'élément View le plus élevé de votre XML, à condition que sa hauteur et sa largeur soient définies sur match_parent. (Cela est vrai tant que votre mise en page occupe tout l'écran.)
Par exemple, si votre code XML commence par quelque chose comme ceci:
<?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" >
Ensuite, findViewById(R.id.entireLayout).getWidth() renverra la largeur de l'écran et findViewById(R.id.entireLayout).getHeight() renverra la hauteur de l'écran.
J'ai une activité d'écran de démarrage avec LinearLayout en tant que vue racine ayant match_parent pour sa largeur et sa hauteur. C'est le code de la méthode onCreate() de cette activité. J'utilise ces mesures dans toutes les autres activités de l'application.
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);
}
});
}
Voici les implémentations pour les méthodes que vous voyez se faire appeler ci-dessus:
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;
}
Il en résulte la hauteur et la largeur de l'écran utilisable, à l'exclusion de tout type de barres (barre d'état, barre de navigation), pour toutes les versions de l'API et différents types de périphériques (téléphones et tablettes).
Kotlin
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
}
La réponse ci-dessus ne fonctionnera pas si la classe Display ne fonctionne pas, alors vous pouvez obtenir la largeur et la hauteur de la manière suivante.
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;
}
Fonction simple compatible avec les versions inférieures également.
/**
* @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()};
}
}
Utiliser:
int width = getScreenSize()[0];
int height = getScreenSize()[1];
Voici une adaptation simple de certaines réponses ci-dessus dans une implémentation de Kotlin. Comme indiqué ci-dessus, il faut que windowsSoftInput = "adjustResize" du manifeste
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)
}
}
Et à utiliser:
val activityRootView = findViewById<ViewGroup>(R.id.activityRoot)
KeyboardWatcher(activityRootView).observer = { visible ->
if (visible) do something here ...
}
Cette fonction renvoie la taille d’écran approximative en pouces.
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;
}
DisplayMetrics dm = getResources().getDisplayMetrics();
float fwidth = dm.density * dm.widthPixels;
float fheight = dm.density * dm.heightPixels;
Si getSize vous génère une erreur en raison de votre minSDKVersion et que vous ne souhaitez pas utiliser de méthodes obsolètes (getWidth & getHeight), la solution getMetrics a été publiée pour la première fois en 2011 par Balaji.K ... Et Nik a ajouté un commentaire expliquant getDisplayMetrics considère également la taille de la barre d'état.
D'autres commentaires font référence à multiplier par l'échelle ( densité ) afin d'obtenir la valeur de flottant précise des dimensions. Testé sous Android v2.2 (API 8) et v4.0 avec de bons résultats et pas d'erreurs/avertissements .
Je pense que c'est le plus simple
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}")
}
J'ai utilisé les propositions ci-dessus et créé une version kotlin pour notre question. J'espère que cela fournira une aide supplémentaire à ceux qui utilisent 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
Notez que la hauteur renvoyée par ces API sera inférieure à la hauteur physique du périphérique car la hauteur de la barre de boutons est soustraite.
Par exemple: Sur un Moto X4, il renvoie les pixels corrects en largeur (1080), mais une hauteur de 1776, même si l'écran de l'appareil est de 1920 pixels.