web-dev-qa-db-fra.com

Comment déterminer la largeur de l'écran en termes de dp ou de dip au moment de l'exécution sous Android?

J'ai besoin de coder la disposition des widgets Android à l'aide de dip/dp (dans des fichiers Java). Au moment de l'exécution si je code,

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

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

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

Cela ne semble pas donner de réponse correcte. J'ai créé l'émulateur de WVGA800 dont la résolution d'écran est de 480 sur 800. Lorsque vous exécutez l'émulateur et laissez le code afficher les valeurs de pixel et dp, il atteint 320 dans les deux cas. Cet émulateur est de 240 dpi dont le facteur d'échelle serait de 0,75.

androiddip
166
Khushboo

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

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

Pour les références futures:

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 la classe de configuration

Edit: Comme l’a noté Nick Baicoianu, ceci retourne la largeur/hauteur utilisable de l’écran (utilisable) (qui devrait être intéressant dans la plupart des utilisations). Si vous avez besoin des dimensions de l'affichage actual, restez fidèle à la première réponse.

95
serjlee

Il vous manque la 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 à 160dip en mode portrait, ce sera la moitié de l'écran sur tous les périphériques ldpi/mdpi/hdpi (sauf les tablettes, je pense)

7
Mykhailo Gaidai
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;
7
Supun Madushanka

Que diriez-vous d'utiliser ceci à la place?

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

Réponse en kotlin:

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

Si vous souhaitez 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.

1
math channel

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

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 en activité:

Screen screen = new Screen(this); // Setting Screen
screen.getWidth();
screen.getHeight();
0
Ali Azaz Alam