Come determinare la larghezza dello schermo in termini di dp o dip in fase di esecuzione in Android?

Devo codificare il layout dei widget Android usando dip / dp (nei file java). In fase di esecuzione se codice

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

questo restituisce la larghezza dello schermo in pixel (px). Per convertirlo in dp, ho codificato:

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

questo non sembra restituire la risposta corretta. Ho creato l'emulatore di WVGA800 la cui risoluzione dello schermo è 480 per 800. Quando esegui l'emulatore e consenti al codice di stampare i valori di pixel e dp, è arrivato a 320 in entrambi. Questo emulatore ha una risoluzione di 240 dpi il cui fattore di scala sarebbe 0,75.

Prova questo

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;

O

Grazie @ Tomáš Hubálek

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

Mi sono imbattuto in questa domanda da Google e in seguito ho trovato una soluzione semplice valida per API> = 13.

Per riferimenti futuri:

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.

Vedi riferimento alla classe di configurazione

Modifica: come notato da Nick Baicoianu, questo restituisce la larghezza / altezza utilizzabili dello schermo (che dovrebbero essere quelli interessanti nella maggior parte degli usi). Se sono necessarie le dimensioni effettive del display, attenersi alla risposta superiore.

Manca un valore di densità predefinito di 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

In altre parole, se si progetta un layout con larghezza pari a 160 dpi in modalità verticale, sarà la metà dello schermo su tutti i dispositivi ldpi / mdpi / hdpi (tranne i tablet, penso)

Che ne dici di usare questo invece?

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;

Risposta in kotlin:

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

Semplificato per Kotlin:

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

Ottieni larghezza e altezza dello schermo in termini di DP con qualche buona decorazione:

Passaggio 1: creare l'interfaccia

public interface ScreenInterface {

   float getWidth();

   float getHeight();

}

Passaggio 2: creare una classe implementatore

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

Passaggio 3: ottieni larghezza e altezza nell'attività:

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

Se vuoi solo conoscere la larghezza dello schermo, puoi semplicemente cercare la "larghezza dello schermo più piccola" nelle opzioni dello sviluppatore. Puoi persino modificarlo.

Prova questo:

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

Il tuo problema è con il lancio del float su un int, perdendo precisione. Dovresti anche moltiplicare per il fattore e non dividere.

Fai questo:

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