Convertendo pixels em dp

Eu criei meu aplicativo com a altura e largura fornecidas em pixels para um dispositivo Pantech cuja resolução é 480x800.

Preciso converter altura e largura para um dispositivo G1.
Eu pensei que convertê-lo em dp resolverá o problema e fornecerá a mesma solução para os dois dispositivos.

Existe alguma maneira fácil de converter pixels em dp?
Alguma sugestão?

// Converts 14 dip into its equivalent px
float dip = 14f;
Resources r = getResources();
float px = TypedValue.applyDimension(
    TypedValue.COMPLEX_UNIT_DIP,
    dip,
    r.getDisplayMetrics()
);

/**
 * This method converts dp unit to equivalent pixels, depending on device density. 
 * 
 * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent px equivalent to dp depending on device density
 */
public static float convertDpToPixel(float dp, Context context){
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

/**
 * This method converts device specific pixels to density independent pixels.
 * 
 * @param px A value in px (pixels) unit. Which we need to convert into db
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent dp equivalent to px value
 */
public static float convertPixelsToDp(float px, Context context){
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Coloque preferencialmente em uma classe Util.java

public static float dpFromPx(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float pxFromDp(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}

float density = context.getResources().getDisplayMetrics().density;
float px = someDpValue * density;
float dp = somePxValue / density;

density é igual a

• .75ativado ldpi( 120dpi)
• 1.0ativado mdpi( 160dpi; linha de base)
• 1.5ativado hdpi( 240dpi)
• 2.0ativado xhdpi( 320dpi)
• 3.0ativado xxhdpi( 480dpi)
• 4.0ativado xxxhdpi( 640dpi)

Use este conversor online para brincar com os valores de dpi.

EDIT: Parece que não há relação 1: 1 entre dpibucket e density. Parece que o Nexus 5Xser xxhdpitem um densityvalor de 2.625(em vez de 3). Veja você mesmo nas Métricas do dispositivo .

Você pode usar isso .. sem contexto

public static int pxToDp(int px) {
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

public static int dpToPx(int dp) {
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

Como o @Stan mencionou .. usar essa abordagem pode causar problemas se o sistema alterar a densidade. Então, fique ciente disso!

Pessoalmente, estou usando o Contexto para fazer isso. É apenas outra abordagem com a qual eu queria compartilhar você

Se você pode usar o XML das dimensões, é muito simples!

No seu res/values/dimens.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="thumbnail_height">120dp</dimen>
    ...
    ...
</resources>

Então no seu Java:

getResources().getDimensionPixelSize(R.dimen.thumbnail_height);

De acordo com o Guia de desenvolvimento do Android:

px = dp * (dpi / 160)

Mas, muitas vezes, você deseja fazer isso de maneira inversa ao receber um design declarado em pixels. Assim:

dp = px / (dpi / 160)

Se você estiver em um dispositivo de 240 dpi, essa proporção é de 1,5 (como mencionado anteriormente), então isso significa que um ícone de 60px é igual a 40dp no aplicativo.

Sem Contextmétodos estáticos elegantes:

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Para DP to Pixel

Crie um valor em dimens.xml

<dimen name="textSize">20dp</dimen>

Obtenha esse valor pixelcomo:

int sizeInPixel = context.getResources().getDimensionPixelSize(R.dimen.textSize);

Portanto, você pode usar o formulador a seguir para calcular a quantidade correta de pixels de uma dimensão especificada em dp

public int convertToPx(int dp) {
    // Get the screen's density scale
    final float scale = getResources().getDisplayMetrics().density;
    // Convert the dps to pixels, based on density scale
    return (int) (dp * scale + 0.5f);
}

Para quem usa o Kotlin:

val Int.toPx: Int
    get() = (this * Resources.getSystem().displayMetrics.density).toInt()

val Int.toDp: Int
    get() = (this / Resources.getSystem().displayMetrics.density).toInt()

Uso:

64.toPx
32.toDp

Há um utilitário padrão no SDK do Android: http://developer.android.com/reference/android/util/TypedValue.html

float resultPix = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,getResources().getDisplayMetrics())

usando o kotlin-extension torna melhor

fun Int.toPx(context: Context): Int = (this * context.resources.displayMetrics.density).toInt()

fun Int.toDp(context: Context): Int = (this / context.resources.displayMetrics.density).toInt()

ATUALIZAR:

Como displayMetricsfaz parte dos Recursos compartilhados globais , podemos usarResources.getSystem()

fun Int.toPx(): Int = (this * Resources.getSystem().displayMetrics.density).toInt()

fun Int.toDp(): Int = (this / Resources.getSystem().displayMetrics.density).toInt()

Isso deve fornecer a conversão dp para pixels:

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

Isso deve fornecer os pixels de conversão para dp:

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Kotlin

fun convertDpToPixel(dp: Float, context: Context): Float {
    return dp * (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

fun convertPixelsToDp(px: Float, context: Context): Float {
    return px / (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

Java

public static float convertDpToPixel(float dp, Context context) {
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

public static float convertPixelsToDp(float px, Context context) {
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Provavelmente, a melhor maneira de obter a dimensão dentro de values ​​/ dimen é obtendo a dimensão diretamente do método getDimension (), ela retornará a dimensão já convertida em valor de pixel.

context.getResources().getDimension(R.dimen.my_dimension)

Apenas para explicar melhor isso,

getDimension(int resourceId) 

retornará a dimensão já convertida em pixel AS A FLOAT.

getDimensionPixelSize(int resourceId)

retornará o mesmo, mas truncado para int, portanto AS INTEGER.

Consulte referência Android

public static int dp2px(Resources resource, int dp) {
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,   dp,resource.getDisplayMetrics());
}

  public static float px2dp(Resources resource, float px)  {
    return (float) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, px,resource.getDisplayMetrics());
}

onde o recurso é context.getResources ().

como isso:

public class ScreenUtils {

    public static float dpToPx(Context context, float dp) {
        if (context == null) {
            return -1;
        }
        return dp * context.getResources().getDisplayMetrics().density;
    }

    public static float pxToDp(Context context, float px) {
        if (context == null) {
            return -1;
        }
        return px / context.getResources().getDisplayMetrics().density;
    }
}

dependente do contexto, retornar valor flutuante, método estático

from: https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ScreenUtils.java#L15

Abordagem mais elegante usando a função de extensão do kotlin

/**
 * Converts dp to pixel
 */
val Int.dpToPx: Int get() = (this * Resources.getSystem().displayMetrics.density).toInt()

/**
 * Converts pixel to dp
 */
val Int.pxToDp: Int get() = (this / Resources.getSystem().displayMetrics.density).toInt()

Uso:

println("16 dp in pixel: ${16.dpToPx}")
println("16 px in dp: ${16.pxToDp}")

float scaleValue = getContext().getResources().getDisplayMetrics().density;
int pixels = (int) (dps * scaleValue + 0.5f);

Caso esteja desenvolvendo um aplicativo crítico de desempenho, considere a seguinte classe otimizada:

public final class DimensionUtils {

    private static boolean isInitialised = false;
    private static float pixelsPerOneDp;

    // Suppress default constructor for noninstantiability.
    private DimensionUtils() {
        throw new AssertionError();
    }

    private static void initialise(View view) {
        pixelsPerOneDp = view.getResources().getDisplayMetrics().densityDpi / 160f;
        isInitialised = true;
    }

    public static float pxToDp(View view, float px) {
        if (!isInitialised) {
            initialise(view);
        }

        return px / pixelsPerOneDp;
    }

    public static float dpToPx(View view, float dp) {
        if (!isInitialised) {
            initialise(view);
        }

        return dp * pixelsPerOneDp;
    }
}

para converter pixels em dp, use o TypedValue .

Conforme a documentação mencionada: Contêiner para um valor de dados digitado dinamicamente.

e use o método applyDimension :

public static float applyDimension (int unit, float value, DisplayMetrics metrics) 

que Converte um valor de dados complexos descompactado, mantendo uma dimensão em seu valor final de ponto flutuante, como o seguinte:

Resources resource = getResources();
float dp = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, 69, resource.getDisplayMetrics());

Espero que ajude .

É assim que funciona para mim:

DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int  h = displaymetrics.heightPixels;
float  d = displaymetrics.density;
int heightInPixels=(int) (h/d);

Você pode fazer o mesmo para a largura.

Muitas ótimas soluções acima. No entanto, a melhor solução que encontrei é o design do google:

https://design.google.com/devices/

Você deve usar o dp como faria com os pixels. Isso é tudo o que são; exibir pixels independentes. Use os mesmos números que você usaria em uma tela de densidade média e o tamanho estará magicamente correto em uma tela de alta densidade.

No entanto, parece que você precisa da opção fill_parent no seu design de layout. Use fill_parent quando desejar que sua visualização ou controle se expanda para todo o tamanho restante no contêiner pai.

PXe DPsão diferentes, mas semelhantes.

DPé a resolução quando você considera apenas o tamanho físico da tela. Ao usá- DPlo, o layout será dimensionado para outras telas de tamanhos semelhantes com pixeldensidades diferentes .

Ocasionalmente, você realmente deseja pixels, e quando lida com dimensões no código, está sempre lidando com real pixels, a menos que as converta.

Então, em um dispositivo Android, hdpitela de tamanho normal , 800x480 is 533x320em DP(eu acredito). Para converter DPem pixels /1.5, para converter de volta *1.5. Isso é apenas para o tamanho de uma tela e dpiisso mudaria dependendo do design. pixelsPorém, nossos artistas me deram e eu me converti DPcom a 1.5equação acima .

Se você deseja valores inteiros , usar Math.round () arredondará o valor flutuante para o número inteiro mais próximo.

public static int pxFromDp(final float dp) {
        return Math.round(dp * Resources.getSystem().getDisplayMetrics().density);
    }

A melhor resposta vem da própria estrutura do Android: basta usar essa igualdade ...

public static int dpToPixels(final DisplayMetrics display_metrics, final float dps) {
    final float scale = display_metrics.density;
    return (int) (dps * scale + 0.5f);
}

(converte dp em px)

Isso funciona para mim (C #):

int pixels = (int)((dp) * Resources.System.DisplayMetrics.Density + 0.5f);

kotlin

   fun spToPx(ctx: Context, sp: Float): Float {
    return sp * ctx.resources.displayMetrics.scaledDensity
}

fun pxToDp(context: Context, px: Float): Float {
    return px / context.resources.displayMetrics.density
}

fun dpToPx(context: Context, dp: Float): Float {
    return dp * context.resources.displayMetrics.density
}

Java

   public static float spToPx(Context ctx,float sp){
    return sp * ctx.getResources().getDisplayMetrics().scaledDensity;
}

public static float pxToDp(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float dpToPx(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}