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

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?

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

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;

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.

(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.

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

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

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 .

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

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

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>

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.

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?

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.

Utilisation du code suivant dans Activity.

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

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

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

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

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

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.

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

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

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

getResources().getDisplayMetrics().heightPixels;

et la largeur en utilisant

getResources().getDisplayMetrics().widthPixels; 

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;

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

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

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.

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

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
}

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

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.