Comment déterminer la largeur de l'écran en termes de dp ou de dip lors de l'exécution dans Android?

J'ai besoin de coder la disposition des widgets Android en utilisant dip / dp (dans les fichiers java). Au moment de l'exécution si je code

int pixel=this.getWindowManager().getDefaultDisplay().getWidth(),;

cela renvoie la largeur de l'écran en pixels (px). Pour convertir cela en dp, j'ai codé:

int dp =pixel/(int)getResources().getDisplayMetrics().density ;

cela ne semble pas renvoyer la bonne réponse. J'ai fait l'émulateur de WVGA800 dont la résolution d'écran est de 480 par 800. Lorsque vous exécutez l'émulateur et laissez le code imprimer les valeurs de pixel et de dp, il est venu à 320 dans les deux. Cet émulateur est de 240 dpi dont le facteur d'échelle serait de 0,75.

Essaye ça

Display display = getWindowManager().getDefaultDisplay();
DisplayMetrics outMetrics = new DisplayMetrics ();
display.getMetrics(outMetrics);

float density  = getResources().getDisplayMetrics().density;
float dpHeight = outMetrics.heightPixels / density;
float dpWidth  = outMetrics.widthPixels / density;

OU

Merci @ Tomáš Hubálek

DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();    
float dpHeight = displayMetrics.heightPixels / displayMetrics.density;
float dpWidth = displayMetrics.widthPixels / displayMetrics.density;

Je suis tombé sur cette question de Google, et plus tard j'ai trouvé une solution simple valable pour l'API> = 13.

Pour de futures références:

Configuration configuration = yourActivity.getResources().getConfiguration();
int screenWidthDp = configuration.screenWidthDp; //The current width of the available screen space, in dp units, corresponding to screen width resource qualifier.
int smallestScreenWidthDp = configuration.smallestScreenWidthDp; //The smallest screen size an application will see in normal operation, corresponding to smallest screen width resource qualifier.

Voir Référence de classe de configuration

Edit: Comme l'a noté Nick Baicoianu, cela renvoie la largeur / hauteur utilisable de l'écran (qui devrait être intéressante dans la plupart des utilisations). Si vous avez besoin des dimensions d'affichage réelles , respectez la première réponse.

Il vous manque une valeur de densité par défaut de 160.

    2 px = 3 dip if dpi == 80(ldpi), 320x240 screen
    1 px = 1 dip if dpi == 160(mdpi), 480x320 screen
    3 px = 2 dip if dpi == 240(hdpi), 840x480 screen

En d'autres termes, si vous concevez votre mise en page avec une largeur égale à 160 dip en mode portrait, ce sera la moitié de l'écran sur tous les appareils ldpi / mdpi / hdpi (sauf les tablettes, je pense)

Que diriez-vous d'utiliser à la place?

final DisplayMetrics displayMetrics=getResources().getDisplayMetrics();
final float screenWidthInDp=displayMetrics.widthPixels/displayMetrics.density;
final float screenHeightInDp=displayMetrics.heightPixels/displayMetrics.density;

DisplayMetrics displayMetrics = new DisplayMetrics();

getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);

int width_px = Resources.getSystem().getDisplayMetrics().widthPixels;

int height_px =Resources.getSystem().getDisplayMetrics().heightPixels;

int pixeldpi = Resources.getSystem().getDisplayMetrics().densityDpi;


int width_dp = (width_px/pixeldpi)*160;
int height_dp = (height_px/pixeldpi)*160;

Réponse en kotlin:

  context?.let {
        val displayMetrics = it.resources.displayMetrics
        val dpHeight = displayMetrics.heightPixels / displayMetrics.density
        val dpWidth = displayMetrics.widthPixels / displayMetrics.density
    }

Simplifié pour Kotlin:

val widthDp = resources.displayMetrics.run { widthPixels / density }
val heightDp = resources.displayMetrics.run { heightPixels / density }

Obtenez la largeur et la hauteur de l'écran en termes de DP avec une bonne décoration:

Étape 1: créer une interface

public interface ScreenInterface {

   float getWidth();

   float getHeight();

}

Étape 2: créer une classe d'implémenteur

public class Screen implements ScreenInterface {
    private Activity activity;

    public Screen(Activity activity) {
        this.activity = activity;
    }

    private DisplayMetrics getScreenDimension(Activity activity) {
        DisplayMetrics displayMetrics = new DisplayMetrics();
        activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
        return displayMetrics;
    }

    private float getScreenDensity(Activity activity) {
        return activity.getResources().getDisplayMetrics().density;
    }

    @Override
    public float getWidth() {
        DisplayMetrics displayMetrics = getScreenDimension(activity);
        return displayMetrics.widthPixels / getScreenDensity(activity);
    }

    @Override
    public float getHeight() {
        DisplayMetrics displayMetrics = getScreenDimension(activity);
        return displayMetrics.heightPixels / getScreenDensity(activity);
    }
} 

Étape 3: Obtenez la largeur et la hauteur de l'activité:

Screen screen = new Screen(this); // Setting Screen
screen.getWidth();
screen.getHeight();

Si vous voulez simplement connaître la largeur de votre écran, vous pouvez simplement rechercher la "plus petite largeur d'écran" dans vos options de développement. Vous pouvez même le modifier.

Essaye ça:

Display display   = getWindowManager().getDefaultDisplay();
Point displaySize = new Point();
display.getSize(displaySize);
int width  = displaySize.x;
int height = displaySize.y;

Votre problème est de lancer le flotteur à un entier, perdant ainsi sa précision. Vous devez également multiplier par le facteur et non pas diviser.

Faites ceci:

int dp = (int)(pixel*getResources().getDisplayMetrics().density);