Como determinar a largura da tela em termos de dp ou dip em tempo de execução no Android?

Preciso codificar o layout dos widgets do Android usando dip / dp (em arquivos java). Em tempo de execução, se eu codificar

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

isso retorna a largura da tela em pixels (px). Para converter isso em dp, eu codifiquei:

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

Isso não parece estar retornando a resposta correta. Eu criei o emulador de WVGA800, cuja resolução de tela é de 480 por 800. Quando o emulador é executado e o código imprime os valores de pixel e dp, chegou a 320 em ambos. Este emulador é de 240 dpi cujo fator de escala seria 0,75.

Tente isto

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

Obrigado @ Tomáš Hubálek

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

Eu me deparei com essa pergunta do Google e, mais tarde, encontrei uma solução fácil, válida para a API> = 13.

Para referências futuras:

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.

Consulte Referência da classe de configuração

Editar: Como observado por Nick Baicoianu, isso retorna a largura / altura utilizável da tela (que devem ser as mais interessantes na maioria dos usos). Se você precisar das dimensões reais da tela, atenha-se à resposta superior.

Está faltando o valor de densidade padrão 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

Em outras palavras, se você projetar seu layout com largura igual a 160dip no modo retrato, será metade da tela em todos os dispositivos ldpi / mdpi / hdpi (exceto os tablets, eu acho)

Que tal usar isso?

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;

Resposta em kotlin:

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

Simplificado para Kotlin:

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

Obtenha largura e altura da tela em termos de DP com uma boa decoração:

Etapa 1: criar interface

public interface ScreenInterface {

   float getWidth();

   float getHeight();

}

Etapa 2: criar classe de implementador

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

Etapa 3: obtenha largura e altura na atividade:

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

Se você quer apenas saber sobre a largura da tela, basta pesquisar por "menor largura de tela" nas opções do desenvolvedor. Você pode até editá-lo.

Tente o seguinte:

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

Seu problema está em converter o float para um int, perdendo precisão. Você também deve multiplicar com o fator e não dividir.

Faça isso:

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