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 à partir du bord supérieur et m pixels à partir du bord droit). Par conséquent, je dois obtenir la largeur de l’écran et la hauteur de l’écran, puis définir la position:

 int px = screenWidth - m; int py = screenHeight - n; 

Comment puis-je obtenir screenWidth et screenHeight dans l’activité principale?

Si vous voulez les dimensions d’affichage 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 l’ Display par défaut via WINDOW_SERVICE :

 WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); Display display = wm.getDefaultDisplay(); 

Avant que getSize soit introduit (au niveau 13 de l’API), vous pouvez 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 

Pour le cas d’utilisation que vous décrivez cependant, une marge / remplissage dans la mise en page semble plus approprié.

Une autre manière est: DisplayMesortingcs

Structure décrivant des informations générales sur un affichage, telles que sa taille, sa densité et sa mise à l’échelle. Pour accéder aux membres DisplayMesortingcs, initialisez un object comme celui-ci:

 DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); getWindowManager().getDefaultDisplay().getMesortingcs(mesortingcs); 

Nous pouvons utiliser widthPixels pour obtenir des informations pour:

“La largeur absolue de l’affichage en pixels.”

Exemple:

 Log.d("ApplicationTagName", "Display width in px is " + mesortingcs.widthPixels); 

Un moyen est:

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

Il est obsolète et vous devriez essayer le code suivant à la place. Les deux premières lignes de code vous donnent les objectives DisplayMesortingcs. Cet object contient les champs tels que heightPixels, widthPixels.

 DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); getWindowManager().getDefaultDisplay().getMesortingcs(mesortingcs); int height = mesortingcs.heightPixels; int width = mesortingcs.widthPixels; 

Cela peut ne pas répondre à votre question, mais il pourrait ê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 vue mais que votre code est en cours d’exécution (par exemple, dans onCreate() ), vous pouvez configurer un ViewTreeObserver.OnGlobalLayoutListener avec View.getViewTreeObserver().addOnGlobalLayoutListener() et y placer le code correspondant à la dimension de la vue. Le rappel de l’auditeur sera appelé lorsque la mise en page aura été mise en page.

(Réponse 2012, peut-être obsolète) Si vous souhaitez prendre en charge pre Honeycomb, vous devrez mettre en place une compatibilité descendante avant 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 obsolètes finiront par être retirées des SDK les plus récents, mais alors que nous comptons encore sur la plupart de nos utilisateurs disposant d’Android 2.1, 2.2 et 2.3, c’est ce qui nous rest.

J’ai essayé toutes les “solutions” possibles sans succès et j’ai remarqué que l’application “Dalvik Explorer” d’Elliott Hughes affichait toujours une dimension correcte sur n’importe quelle version d’Android / OS. 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(); DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); d.getMesortingcs(mesortingcs); // since SDK_INT = 1; widthPixels = mesortingcs.widthPixels; heightPixels = mesortingcs.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 (évitez de déclencher des exceptions sur une version de système d’exploitation non prise en charge):

 WindowManager w = activity.getWindowManager(); Display d = w.getDefaultDisplay(); DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); d.getMesortingcs(mesortingcs); // since SDK_INT = 1; widthPixels = mesortingcs.widthPixels; heightPixels = mesortingcs.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) { } 

Pour accéder à la hauteur de la barre d’état des appareils Android, nous préférons un moyen programmatique de l’obtenir:

Code exemple

 int resId = getResources().getIdentifier("status_bar_height", "dimen", "android"); if (resId > 0) { result = getResources().getDimensionPixelSize(resId); } 

Le result variable donne la hauteur dans le pixel.

Pour un access rapide

Entrez la description de l'image ici

Pour plus d’informations sur la hauteur de la Title bar de Title bar Navigation bar et de Content View , consultez les tailles d’écran des périphériques Android .

Manière la plus simple:

  int screenHeight = getResources().getDisplayMesortingcs().heightPixels; int screenWidth = getResources().getDisplayMesortingcs().widthPixels; 

D’abord, obtenez la vue (par exemple, par findViewById() ) et ensuite vous pouvez utiliser getWidth () sur la vue elle-même.

J’ai deux fonctions, une pour l’envoi du contexte et l’autre pour 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; } 

Pour une mise à l’échelle dynamic à l’aide de XML, il existe un atsortingbut appelé “android: layout_weight”

L’exemple ci-dessous, modifié à partir de la réponse de Synic sur ce sujet , montre un bouton qui occupe 75% de l’écran (poids = 0,25) et une vue texte occupant les 25% restants de l’écran (poids = 0,75).

   

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 soin de la dépréciation.

N’est-ce pas une meilleure solution? DisplayMesortingcs est livré avec tout ce dont vous avez besoin et fonctionne à partir de l’API 1.

 public void getScreenInfo(){ DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); getActivity().getWindowManager().getDefaultDisplay().getMesortingcs(mesortingcs); heightPixels = mesortingcs.heightPixels; widthPixels = mesortingcs.widthPixels; density = mesortingcs.density; densityDpi = mesortingcs.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 getRealMesortingcs , mais cela ne fonctionne que pour les versions 17+.

Est-ce que je manque quelque chose?

Il suffit d’append à la réponse de Francesco. L’autre observateur qui est le plus apte, si vous voulez trouver l’emplacement dans la fenêtre ou l’emplacement de l’écran, est ViewTreeObserver.OnPreDrawListener ()

Cela peut également être utilisé pour trouver d’autres atsortingbuts d’une vue qui est la plupart du temps inconnue à l’heure de onCreate (), par exemple la position défilée, la position mise à l’échelle.

Trouver la largeur et la hauteur de l’écran:

 width = getWindowManager().getDefaultDisplay().getWidth(); height = getWindowManager().getDefaultDisplay().getHeight(); 

En utilisant ceci, nous pouvons obtenir le dernier et le dernier SDK 13.

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

Utilisation du code suivant dans Activity.

 DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); getWindowManager().getDefaultDisplay().getMesortingcs(mesortingcs); int height = mesortingcs.heightPixels; int wwidth = mesortingcs.widthPixels; 
 DisplayMesortingcs dimension = new DisplayMesortingcs(); getWindowManager().getDefaultDisplay().getMesortingcs(dimension); int w = dimension.widthPixels; int h = dimension.heightPixels; 

Il faut dire que si vous n’êtes pas dans Activity , mais dans View (ou si vous avez une variable de type View dans votre scope), il n’est pas nécessaire d’utiliser WINDOW_SERVICE . Ensuite, vous pouvez utiliser au moins deux façons.

Premier:

 DisplayMesortingcs dm = yourView.getContext().getResources().getDisplayMesortingcs(); 

Seconde:

 DisplayMesortingcs dm = new DisplayMesortingcs(); yourView.getDisplay().getMesortingcs(dm); 

Toutes les 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); DisplayMesortingcs dm = new DisplayMesortingcs(); getWindowManager().getDefaultDisplay().getMesortingcs(dm); Ssortingng str_ScreenSize = "The Android Screen is: " + dm.widthPixels + " x " + dm.heightPixels; TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize); mScreenSize.setText(str_ScreenSize); } } 

J’ai trouvé que ça faisait l’affaire.

 Rect dim = new Rect(); getWindowVisibleDisplayFrame(dim); 

Pour obtenir les dimensions de l’écran, utilisez des mésortingques d’affichage

 DisplayMesortingcs displayMesortingcs = new DisplayMesortingcs(); if (context != null) WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); Display defaultDisplay = windowManager.getDefaultDisplay(); defaultDisplay.getRealMesortingcs(displayMesortingcs); } 

Obtenir la hauteur et la largeur en pixels

 int width =displayMesortingcs.widthPixels; int height =displayMesortingcs.heightPixels; 

Ce n’est pas une réponse pour l’OP, car il voulait les dimensions d’affichage en pixels réels. Je voulais les dimensions en “pixels indépendants du périphérique”, et en rassemblant les réponses ici https://stackoverflow.com/a/17880012/253938 et ici https://stackoverflow.com/a/6656774/253938 avec ça:

  DisplayMesortingcs displayMesortingcs = Resources.getSystem().getDisplayMesortingcs(); int dpHeight = (int)(displayMesortingcs.heightPixels / displayMesortingcs.density + 0.5); int dpWidth = (int)(displayMesortingcs.widthPixels / displayMesortingcs.density + 0.5); 

Il existe un moyen non obsolète de le faire en utilisant DisplayMesortingcs (API 1), ce qui évite les problèmes d’essai:

  // initialize the DisplayMesortingcs object DisplayMesortingcs deviceDisplayMesortingcs = new DisplayMesortingcs(); // populate the DisplayMesortingcs object with the display characteristics getWindowManager().getDefaultDisplay().getMesortingcs(deviceDisplayMesortingcs); // get the width and height screenWidth = deviceDisplayMesortingcs.widthPixels; screenHeight = deviceDisplayMesortingcs.heightPixels; 

J’emballerais 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 ce code:

 setContentView(R.layout.main); Display display = getWindowManager().getDefaultDisplay(); final int width = (display.getWidth()); final int height = (display.getHeight()); 

Afficher 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 getDisplayMesortingcs(context).widthPixels; } public static int getHeightScreen(Context context) { return getDisplayMesortingcs(context).heightPixels; } private static DisplayMesortingcs getDisplayMesortingcs(Context context) { DisplayMesortingcs displayMesortingcs = new DisplayMesortingcs(); WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); wm.getDefaultDisplay().getMesortingcs(displayMesortingcs); return displayMesortingcs; } 

Vous pouvez obtenir la taille en utilisant:

 getResources().getDisplayMesortingcs().heightPixels; 

et la largeur en utilisant

 getResources().getDisplayMesortingcs().widthPixels; 

Il y a des moments où vous devez connaître les dimensions précises de l’espace disponible pour une mise en page lors de la création d’une activité. Après quelques reflections, j’ai élaboré cette façon de faire.

 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 append 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 voulez pas la surcharge de WindowManagers, Points ou Displays, vous pouvez récupérer les atsortingbuts height et width de l’élément View le plus élevé dans 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 XML commence par quelque chose comme ceci:

   

Ensuite, findViewById(R.id.entireLayout).getWidth() retournera la largeur de l’écran et findViewById(R.id.entireLayout).getHeight() retournera la hauteur de l’écran.

Pour qui recherche une dimension d’écran utilisable sans barre d’état et barre d’action (également grâce à la réponse de Swapnil):

 DisplayMesortingcs dm = getResources().getDisplayMesortingcs(); 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().resolveAtsortingbute(android.R.attr.actionBarSize, typedValue, true)){ screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId); } 

J’ai une activité écran de démarrage avec un LinearLayout en tant que vue racine qui a 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 appelées ci-dessus:

 private int getRawDisplayWidthPreHoneycomb() { WindowManager windowManager = getWindowManager(); Display display = windowManager.getDefaultDisplay(); DisplayMesortingcs displayMesortingcs = new DisplayMesortingcs(); display.getMesortingcs(displayMesortingcs); int widthPixels = displayMesortingcs.widthPixels; int heightPixels = displayMesortingcs.heightPixels; return Math.min(widthPixels, heightPixels); } private int getRawDisplayHeightPreHoneycomb() { WindowManager w = getWindowManager(); Display d = w.getDefaultDisplay(); DisplayMesortingcs mesortingcs = new DisplayMesortingcs(); d.getMesortingcs(mesortingcs); int widthPixels = mesortingcs.widthPixels; int heightPixels = mesortingcs.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; } 

Cela se traduit par la hauteur et la largeur de l’écran utilisable, à l’exclusion de tout type de barre (barre d’état, barre de navigation), pour toutes les versions d’API et différents types de périphériques (téléphones et tablettes).