La conversion des pixels de la dp

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

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

density est égal à

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

Utiliser cette convertisseur en ligne jouer avec les valeurs dpi.

EDIT:
Il semble que il n'y a pas de relation 1:1 entre dpi seau et density. Il ressemble à la Nexus 5X être xxhdpi a un density valeur de 2.625 (au lieu de 3). Voyez par vous-même dans le Des Mesures De L'Appareil.

Selon le Développement Android Guide:

px = dp * (dpi / 160)

Mais souvent, vous aurez envie de faire effectuer cela dans l'autre sens lorsque vous recevez une conception qui est exprimée en pixels. Donc:

dp = px / (dpi / 160)

Si vous êtes sur un 240dpi appareil, ce ratio est de 1,5 (comme indiqué précédemment), ce qui signifie qu'un 60px icône est égal à 40dp dans l'application.

Sans Context, élégant méthodes statiques:

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

Par conséquent, vous pouvez utiliser les éléments suivants formulateur pour calculer la bonne quantité de pixels à partir d'une dimension spécifiée dans 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);
}

Il y a un défaut util dans android SDK:
http://developer.android.com/reference/android/util/TypedValue.html

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

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

à l'aide de kotlin-extension permet de mieux

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

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

Mise à JOUR:

En raison de displayMetrics fait partie de mondial de Ressources partagées, nous pouvons utiliser Resources.getSystem()

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

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

comme ceci:

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

dépend du Contexte, de retour de valeur float, méthode statique

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

Plus élégant approche à l'aide de kotlin de la fonction d'extension de

/**
 * 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()

Utilisation:

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

Vous devez utiliser des dp comme vous le feriez pixels. C'est tout ce qu'ils sont; affichage de pixels indépendants. Utiliser les mêmes numéros que vous le feriez sur une densité moyenne de l'écran, et la taille sera magiquement correcte sur une haute densité de l'écran.

Cependant, il semble que vous avez besoin est la fill_parent option dans votre conception de mise en page. Utilisation fill_parent lorsque vous souhaitez que votre point de vue ou de contrôle de l'étendre à tout le reste de la taille du conteneur parent.

PX et DP sont différents, mais semblables.

DP est la résolution lorsque vous seul facteur de la taille physique de l'écran. Lorsque vous utilisez DP il va mettre à l'échelle votre disposition pour d'autres de même taille des écrans avec de différents pixel densités.

Parfois, vous voulez vraiment pixels si, et quand vous avez affaire avec des dimensions dans le code, vous aurez toujours affaire à de vrais pixels, à moins que vous les convertir.

Donc sur un appareil android, taille normale, hdpi écran, 800x480 is 533x320 dans DP (je crois). Pour convertir DP en pixels /1.5, de se reconvertir *1.5. Ce n'est que pour une taille d'écran et de dpi, il serait de changer en fonction de la conception. Nos artistes me donner pixels et si je convertir DP ci-dessus 1.5 équation.

Si vous voulez Entier valeurs, puis en utilisant les Mathématiques.round() arrondit le flotteur à l'entier le plus proche.

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

Pour Xamarin.Android

float DpToPixel(float dp)
{
    var resources = Context.Resources;
    var metrics = resources.DisplayMetrics;
    return dp * ((float)metrics.DensityDpi / (int)DisplayMetricsDensity.Default);
}

Ce qui en fait un non-statique est nécessaire lorsque vous faites un moteur de rendu personnalisé

HTML:

  ((MyviewHolder) holder).videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                @Override
                public void onPrepared(final MediaPlayer mediaPlayer) {
                    mediaPlayer.setLooping(true);
                    ((MyviewHolder) holder).spinnerView.setVisibility(View.GONE);
                    mediaPlayer.setOnVideoSizeChangedListener(new MediaPlayer.OnVideoSizeChangedListener() {
                        @Override
                        public void onVideoSizeChanged(MediaPlayer mp, int width, int height) {
                /*
                 * add media controller
                 */
                            MediaController controller = new MediaController(mContext);
                            float density = mContext.getResources().getDisplayMetrics().density;
                            float px = 55 * density;
//                       float dp = somePxValue /density;
                            controller.setPadding(0, 0, 0, (int) (px));

                            ((MyviewHolder) holder).videoView.setMediaController(controller);


                        }
                    });
                }
            });