Obtenir les dimensions de l'écran en pixels

Question

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?

Answer 1

Si vous souhaitez 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 activité , vous pouvez obtenir le affichage par défaut 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 l'introduction de getSize (dans l'API de niveau 13), vous pouviez utiliser les méthodes getWidth et getHeight qui sont désormais obsolètes:

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

Toutefois, pour le cas d'utilisation que vous décrivez, une marge / un remplissage dans la présentation semble plus approprié.

Une autre solution consiste à: DisplayMetrics

  

Structure décrivant des informations générales sur un affichage, telles que sa taille, sa densité et son échelle de police. 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);

Answer 2

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 objets DisplayMetrics . Cet objet contient des champs tels que heightPixels , widthPixels .

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

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

Answer 3

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 été Si vous avez déjà disposé (par exemple, dans onCreate () ), vous pouvez configurer un ViewTreeObserver.OnGlobalLayoutListener avec View.getViewTreeObserver (). addOnGlobalLayoutListener () mettez le code correspondant à la dimension de la vue. Le rappel de l'auditeur sera appelé lorsque la mise en page aura été aménagée.

Answer 4

(réponse 2012, peut-être obsolète) Si vous souhaitez prendre en charge une version antérieure à Honeycomb, vous devez activer la compatibilité avec les versions antérieures à 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 éventuellement retirées des SDK les plus récents, mais bien que nous utilisions toujours la plupart de nos utilisateurs dotés d’Android 2.1, 2.2 et 2.3, c’est ce qui nous reste.

Answer 5

J'ai essayé toutes les "solutions" possibles. sans succès et j’ai remarqué que le "Dalvik Explorer" d’Elliott Hughes L'application affiche toujours les dimensions correctes sur toutes les versions de périphériques / systèmes d'exploitation Android. J'ai fini par regarder son projet open source que l'on peut trouver 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 déclenchement sur les versions de système d'exploitation non prises 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) {
}

Answer 6

Manière la plus simple:

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

Answer 7

Pour accéder à la hauteur de la barre d'état pour les appareils Android, nous préférons un moyen par programmation 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 barre de titre , barre de navigation et affichage du contenu , veuillez consulter Taille de l'écran du périphérique Android .

Answer 8

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

Answer 9

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

Answer 10

Pour la 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 , affiche un bouton occupant 75% de l'écran (poids = 0,25) et un affichage en 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>

Answer 11

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.

Answer 12

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) en utilisant getRealMetrics , mais cela ne fonctionne que sur 17 ans et plus.

Est-ce que je manque quelque chose?

Answer 13

Ajoutons simplement à la réponse de Francesco. L’autre observateur plus apte, si vous voulez connaître l’emplacement dans la fenêtre ou l’emplacement à l’écran est ViewTreeObserver.OnPreDrawListener ()

Ceci peut également être utilisé pour trouver d'autres attributs d'une vue inconnus pour la plupart à l'heure onCreate (), par exemple. la position défilée, la position mise à l'échelle.

Answer 14

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

Answer 15

Utilisation du code suivant dans Activity.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

Answer 16

DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Answer 17

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

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

Answer 18

Besoin de dire que si vous n'êtes pas dans Activité , mais dans Afficher (ou si la variable Vue est dans votre champ) , il n’est pas nécessaire d’utiliser WINDOW_SERVICE . Ensuite, vous pouvez utiliser au moins deux méthodes.

Premier:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

Deuxième:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

Toutes ces méthodes que nous appelons ici ne sont pas obsolètes.

Answer 19

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

Answer 20

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;

Answer 21

Ceci n’est pas une réponse pour le PO car il souhaitait afficher les dimensions en pixels réels. Je voulais connaître les dimensions dans "pixels indépendants du périphérique" et rassembler les réponses à partir d'ici https://stackoverflow.com/a/ 17880012/253938 et ici https://stackoverflow.com/a/6656774/253938 , je suis venu avec ceci:

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

Answer 22

Il existe un moyen non obsolète de faire cela en utilisant 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;

Answer 23

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

Answer 24

Vous pouvez obtenir la hauteur à l'aide de:

getResources().getDisplayMetrics().heightPixels;

et la largeur à l'aide de

getResources().getDisplayMetrics().widthPixels; 

Answer 25

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

Answer 26

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.

Answer 27

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

Answer 28

Il est parfois nécessaire de connaître les dimensions précises de l'espace disponible pour une présentation lorsque vous créez une activité. Après réflexion, j’ai mis au point 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 comme suit:

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

Answer 29

Si vous ne souhaitez pas que les frais généraux de WindowManagers, Points ou Displays soient surchargés, vous pouvez saisir les attributs height et width de l'élément View le plus haut 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.

Answer 30

J'ai une activité d'écran de démarrage avec LinearLayout en tant que vue racine ayant match_parent pour sa largeur & amp; la taille. C'est le code dans 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 des méthodes que vous voyez appelées 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 barre (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).