Comment obtenir des dimensions d'écran en pixels dans Android

1845

J'ai créé des éléments personnalisés et je souhaite les placer par programme dans le coin supérieur droit ( npixels du bord supérieur et mpixels 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 puis-je obtenir screenWidthet screenHeightdans l'activité principale?

Niko Gamulin
la source
Utilisez dp au lieu de px. car il déformera votre mise en page avec d'autres appareils ..
Jawad Zeb
N'oubliez pas de multiplier par getResources (). GetDisplayMetrics (). Densité pour tenir compte de la mise à l'échelle de l'affichage
jmaculate
Cela prouve que la réponse la plus votée n'est pas toujours la meilleure (et beaucoup de gens répètent les réponses pour le représentant). Au lieu de getSize et de la combinaison obsolète getWidth / getHeight (en ignorant les erreurs), essayez Balaji.K getMetrics. Le commentaire de Nik dans sa réponse explique même getDisplayMetricsde considérer la taille du système / barre d'état. Vous pouvez également utiliser la densité comme jmaculate et LoungeKatt ont expliqué avoir la valeur EXACT : DisplayMetrics dm = getResources().getDisplayMetrics(); float fwidth = dm.density * dm.widthPixels;testé dans Android v2.2 (API 8) et v4.0 avec de bons résultats et sans erreurs / avertissements .
Armfoot
DisplayMetrics displaymetrics = new DisplayMetrics (); getWindowManager (). getDefaultDisplay (). getMetrics (displaymetrics); int height = displaymetrics.heightPixels; int width = displaymetrics.widthPixels;
Azahar
une autre façon d'obtenir les DisplayMetrics: Resources.getSystem().getDisplayMetrics(). Vous n'en aurez pas besoin Contextpour les obtenir.
Täg

Réponses:

3479

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 un, Activityvous pouvez obtenir la valeur Displaypar défaut via WINDOW_SERVICE:

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

Si vous êtes dans un fragment et que vous souhaitez y parvenir, utilisez simplement Activity.WindowManager (dans Xamarin.Android) ou getActivity (). GetWindowManager () (en java).

Avant d' getSizeêtre introduit (dans l'API niveau 13), vous pouviez utiliser les méthodes getWidthet getHeightqui sont désormais 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 / remplissage dans la disposition semble plus appropriée.

Une autre façon est: DisplayMetrics

Structure décrivant des informations générales sur un affichage, telles que sa taille, sa densité et la mise à l'échelle de la police. Pour accéder aux membres DisplayMetrics, initialisez un objet comme celui-ci:

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

Nous pouvons utiliser widthPixelspour obtenir des informations sur:

"La largeur absolue de l'affichage en pixels."

Exemple:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);
Josef Pfleger
la source
13
getWidth () ou getSize ()? Que devrais-je utiliser si j'ai besoin que mon application fonctionne sur API <13 ainsi que sur API> 13?
Carol
52
essayez {display.getSize (taille); largeur = taille.x; hauteur = taille.y; } catch (NoSuchMethodError e) {width = display.getWidth (); height = display.getHeight (); }
Arnaud
248
Je ne vois pas pourquoi vous souhaitez utiliser try/catchpour un tel chèque? Pourquoi ne pas simplement utiliser if (android.os.Build.VERSION.SDK_INT >= 13)sans aucune exception levée? try/catchDans un flux d'application normal, je pense que c'est une mauvaise pratique.
Patrik
2
@ A-Live, l'application se briserait également (mais ne planterait pas). Nous, les développeurs, devons pré-vérifier une nouvelle version du système d'exploitation et cela peut simplement masquer un problème. Aussi avec cet argument, on pourrait / devrait entourer toutes les quelques lignes de code avec try / catch, ce qui, à mon avis, est une mauvaise pratique comme déjà mentionné.
Patrik
11
que faire si vous voulez obtenir la taille de l'écran à l'exclusion de la barre de navigation et / ou de la barre de notification
développeur Android
375

Une façon 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 DisplayMetricsobjecs. Ces objets contient les champs comme heightPixels, widthPixels.

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;
Balaji.K
la source
14
Notez que les métriques (largeur, hauteur) changent en fonction de la rotation de l'appareil.
Tony Chan
8
Les métriques renverront la taille de l'affichage, mais HoneyComb et plus, votre activité aura moins d'espace que ce qui est retourné en raison de la barre système.
Guy
3
@Guy cela dépend de votre implémentation. Vous pouvez masquer la barre d'état: requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
Hagai L
79
Existe également de cette façon: getContext (). GetResources (). GetDisplayMetrics (). WidthPixels
Nik
échelle flottante finale = getResources (). getDisplayMetrics (). density; int width = (int) (metrics.widthPixels * scale + 0.5f); - Vous devez tenir compte de la densité de l'appareil lorsque vous le faites de cette façon.
Panier abandonné le
120

Cela ne répond peut-être pas à 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 alors que sa disposition n'a pas encore été présentée (par exemple dans onCreate()) vous pouvez configurer un ViewTreeObserver.OnGlobalLayoutListeneravec View.getViewTreeObserver().addOnGlobalLayoutListener()et y mettre le code approprié qui a besoin de la dimension de la vue. Le rappel de l'auditeur sera appelé lorsque la mise en page aura été présentée.

Francesco Feltrinelli
la source
ou écrivez simplement view.post
Lukas Hanacek
view.post n'est cependant pas garanti de fonctionner. C'est juste une solution de contournement.
marsbear
@marsbear où est-il dit que le fonctionnement View.post()n'est pas garanti? Je suis curieux car je compte également sur cette méthode pour obtenir la taille d'une vue après la mise en page et je ne savais pas qu'elle n'était pas fiable.
Tony Chan
@Turbo Je dis que: p Nous avons déjà utilisé cette solution de contournement et il s'est avéré peu fiable. Cette solution de contournement est basée sur l'hypothèse que la mise en page initiale est effectuée dans le même tour UIThread que l'initialisation. Par conséquent, vous pouvez planifier l'exécution de votre code avant le prochain tour de l'interface utilisateur via post () et tout va bien. Il s'est avéré que la mise en page pouvait prendre encore plus de temps dans certaines circonstances et la vue n'était toujours pas mise en page lors de l'exécution du code publié. Ce que je fais maintenant, c'est ajouter le ViewTreeObserver dans onCreate et le supprimer après le premier onLayout. Initiez vos trucs lors de cette première mise en page.
marsbear
@marsbear importe-t-il d'où Viewvous venez ViewTreeObserver? Ou partagent-ils tous le même?
Tony Chan
109

(Réponse 2012, peut-être obsolète) Si vous souhaitez prendre en charge la version pré Honeycomb, vous devrez mettre en compatibilité descendante 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 obsolètes seront finalement retirées des SDK les plus récents, mais bien que nous comptions toujours sur la plupart de nos utilisateurs avec Android 2.1, 2.2 et 2.3, c'est ce qui nous reste.

digiphd
la source
Oui, c'était de retour en 2012.
digiphd
désolé, permettez-moi de clarifier ce que je voulais dire. Il est hautement improbable que quelqu'un prenne en charge l'API <14 au 22/06/2015
sudocoder
69

J'ai essayé toutes les "solutions" sans succès et j'ai remarqué que l'application "Dalvik Explorer" d'Elliott Hughes affiche toujours la bonne dimension sur n'importe quel appareil Android / version OS. J'ai fini par regarder son projet open source qui se trouve 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 (é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();
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) {
}
Dragan Marjanović
la source
9
C'est le seul article ici qui prend en compte les décorations des fenêtres (barre d'état / barre de menu). a très bien fonctionné pour moi.
Andy Cochrane
5
Génial, cependant, vous ne devriez jamais vous attendre à des exceptions d'incendie de logique métier. Un tir d'exception (même lorsqu'il est pris) est horrible pour les performances. De plus, vous faites plus de travail que nécessaire si le SDK_INT est> 13. Au lieu de cela, vous devez simplement ajouter quelques ifs sur le Build.VERSION.SDK_INT.
Erik B
3
@Erik B, je suis d'accord. J'ai ajouté une version améliorée. J'ai quand même laissé la partie "depuis le SDK 1" juste au cas où quelque chose se passe mal dans try / catch (j'ai vu beaucoup de mauvaises choses dans Android surtout quand vous pensez qu'il est impossible que quelque chose se passe mal donc j'aime garder ça en sécurité :)) . Quoi qu'il en soit, il ne devrait pas y avoir trop de frais généraux car ce calcul ne doit être effectué qu'une seule fois (par exemple, les valeurs peuvent être conservées dans certains attributs statiques).
Dragan Marjanović
8
Notez que ce code est sous licence GPL v3, ce qui a des implications pour l'utilisation dans les applications de production.
TalkLittle
GPL et en fonction de la réflexion pour appeler des méthodes qui pourraient ne pas être présentes dans les futures versions d'Android. Mhhh
Michel
47

Manière la plus simple:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 
Zelleriation
la source
46

Pour accéder à la hauteur de la barre d'état pour les appareils Android, nous préférons une méthode de programmation pour l'obtenir:

Exemple de code

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

La variable resultdonne la hauteur en pixel.

Pour un accès rapide

Entrez la description de l'image ici

Pour plus d' informations sur la hauteur de Title bar, Navigation baret Content View, jeter un regard bienveillant sur Android appareil Tailles de l' écran .

Swapnil Sonar
la source
Juste ce dont j'avais besoin! getResources().getDisplayMetrics().heightPixels + resultdonne la hauteur réelle en plein écran. La réponse de Dragan Marjanović fonctionne également, mais je préfère cette solution beaucoup plus courte et plus simple.
Michel
Cette approche est obsolète depuis Android Marshmallow. La hauteur de la barre d'état peut varier selon l'appareil ou la version Android. Une meilleure utilisation OnApplyWindowInsetsListener.
Heinrich
32

Obtenez d'abord la vue (par exemple par findViewById()), puis vous pouvez utiliser getWidth () sur la vue elle-même.

Marcin Gil
la source
3
C'est en fait ainsi que la documentation vous dit de le faire ... mais c'est un peu inutile si vous n'utilisez PAS une vue. vous utilisez peut-être autre chose, par exemple mglsurfaceview.
gcb
2
c'est mieux car la vue parent peut ne pas avoir la taille de l'affichage. Mais assurez-vous que cela est fait à un point où la vue dont vous interrogez la taille a déjà été disposée, qui ne sera généralement pas à l'intérieur de onCreate (). Vous pouvez utiliser un rappel personnalisé de onWindowFocusChanged (boolean hasFocus) qui sera appelé après que toutes les vues auront été mesurées et ainsi de suite, en vous assurant que vous ne recevrez pas de dimensions incorrectes pour la vue qui vous intéresse ...
Dori
27

J'ai deux fonctions, l'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;
}
Jorgesys
la source
Vous devez ajouter @SuppressLint("NewApi")juste au-dessus de la signature de fonction pour pouvoir compiler.
Adil Malik
Je pense qu'il vaut mieux obtenir la hauteur et la largeur en une seule fois plutôt que dans des appels séparés aux API car sinon ils pourraient être désynchronisés. Cela peut se produire si l'orientation de l'écran change pendant l'exécution de votre code.
Sam
17

Pour une mise à l'échelle dynamique à l'aide de 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 qui occupe 75% de l'écran (poids = 0,25) et une vue texte occupant les 25% restants de l'écran (poids = 0,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>
Crbreingan
la source
17

Voici 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, s'occupe de la dépréciation.

Pijusn
la source
17

N'est-ce pas une bien meilleure solution? DisplayMetrics est livré 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+.

Suis-je en train de manquer quelque chose?

David Corsalini
la source
1
Il ne soustrait pas l'espace pour les contrôles à l'écran (comme sur les tablettes ou les appareils Nexus). En outre, j'obtiens une valeur différente (750 vs 800) sur ma tablette 10 ", selon que l'activité est active lorsque le calcul est terminé. Mais pour moi, c'est plus que correct. Merci!
Steven L
15

Ajout juste à la réponse de Francesco. L'autre observateur qui est plus apte, si vous voulez trouver l'emplacement dans la fenêtre ou l'emplacement dans l'écran est ViewTreeObserver.OnPreDrawListener ()

Cela peut également être utilisé pour trouver d'autres attributs d'une vue qui est principalement inconnue au moment de onCreate (), par exemple la position de défilement, la position à l'échelle.

pellucide
la source
15

Utilisation du code suivant dans Activity.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
Vinothkumar Arputharaj
la source
15

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

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

En utilisant cela, nous pouvons obtenir le SDK 13 le plus récent et supérieur.

// 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);
}
NagarjunaReddy
la source
15
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;
Cristiana Chavez
la source
12

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

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);
Justin
la source
5
Cool mais c'est une chose effrayante à propos de cette méthode dans le code source: ce commentaire
Norbert
12

Besoin de dire que si vous n'êtes pas dans Activity, mais dans View(ou que vous avez une variable de Viewtype dans votre portée), il n'est pas nécessaire d'utiliserWINDOW_SERVICE . Ensuite, vous pouvez utiliser au moins deux façons.

Première:

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.

Sergei Pikalev
la source
12
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);
    }
}
Shoaib Ahmed
la source
12

Pour obtenir les dimensions de l'écran, utilisez des 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);
    }

Obtenez la hauteur et la largeur en pixels

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;
Sharath kumar
la source
9

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 de l'appareil", et rassembler les réponses d'ici https://stackoverflow.com/a/17880012/253938 et ici https://stackoverflow.com/a/6656774/253938 je suis venu avec ça:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);
RenniePet
la source
9

Vous pouvez faire obtenir la hauteur taille à l' aide:

getResources().getDisplayMetrics().heightPixels;

et la largeur en utilisant

getResources().getDisplayMetrics().widthPixels; 
Jéwôm '
la source
8

Il existe un moyen non obsolète de le faire à l'aide de DisplayMetrics (API 1), 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;
paulrehkugler
la source
8

J'envelopperais 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;
}
Simon
la source
Cela se bloque sur un émulateur exécutant Android 4.0 (API 14).
jww
6

Pour ceux qui recherchent une dimension d'écran utilisable sans barre d'état et barre d'action (également grâce à la réponse de 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);
}
Francesco Vadicamo
la source
6

Chargez d'abord 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());

Affichez la largeur et la hauteur en fonction de la résolution de votre écran.

duggu
la source
6

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;
}
sonida
la source
6

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
}
Khemraj
la source
5

Il y a des moments où vous devez connaître les dimensions précises de l'espace disponible pour une mise en page lorsque vous êtes sur la création d'une activité. Après réflexion, j'ai trouvé cette façon de procéder.

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 voulez pas ajouter une autre activité au manifeste Android, vous pouvez le faire de cette façon:

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();
    }
}    
Steve Waring
la source
Évidemment, vous pouvez également repasser la hauteur dans le paquet.
Steve Waring
5

Si vous ne voulez pas les frais généraux des gestionnaires de fenêtres, des points ou des affichages, vous pouvez saisir les attributs de hauteur et de largeur de l'élément View le plus haut 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:

<?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(), retournera la largeur de l'écran et findViewById(R.id.entireLayout).getHeight()retournera la hauteur de l'écran.

christinac
la source