पिक्सेल को dp में बदलना

Question

मैंने अपना एप्लिकेशन एक पिक्सेल डिवाइस के लिए पिक्सेल में दी गई ऊंचाई और चौड़ाई के साथ बनाया है जिसका रिज़ॉल्यूशन है 480x800।

मुझे G1 डिवाइस के लिए ऊंचाई और चौड़ाई बदलने की आवश्यकता है।
मैंने सोचा कि इसे डीपी में परिवर्तित करने से समस्या हल हो जाएगी और दोनों उपकरणों के लिए एक ही समाधान उपलब्ध होगा।

क्या पिक्सल को डीपी में बदलने का कोई आसान तरीका है?
कोई सुझाव?

Comments

यदि आप एकबारगी रूपांतरण करना चाहते हैं (उदाहरण के लिए फ़ोटोशॉप से ​​स्प्राइट निर्यात करने के लिए), तो यहाँ एक निफ्टी कनवर्टर है ।

— पॉल लैमर्ट्स्मा

px, dp, spरूपांतरण सूत्र

— Suragch

web.archive.org/web/20140808234241/http://developer.android.com/…

— caw

Answer 1

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

Comments

नोट: उपरोक्त पिक्सेल के लिए DIPs परिवर्तित कर रहा है। मूल प्रश्न ने पूछा कि पिक्सल को डिप्स में कैसे बदला जाए!

— इरिग जोन्स जोन्स

यहाँ ओपी के लिए एक वास्तविक जवाब है: stackoverflow.com/questions/6656540/…

— qix

इसका मजाकिया जवाब कैसे अधिक उपयोगी है जब यह वास्तव में सवाल का जवाब नहीं देता है -_- मुझे लगा कि मैं चाहता था कि सवाल क्या पूछा गया, फिर मुझे एहसास हुआ कि मैंने नहीं किया! इतना बढ़िया जवाब। मेरा एक सवाल है। मैं अंतिम पैरामिटर कैसे प्राप्त कर सकता हूं applyDimension? क्या मैं बस कर सकता हूं getResource().getDisplayMetrics(), या कुछ और है?

— एंडी

नोट: अपेक्षाकृत महंगा ऑपरेशन। तेज

— एरेस के

यदि Contextवस्तु के उपयोग की कोई पहुँच नहीं हैResources.getSystem().getDisplayMetrics()

— फ़रशाद तहमासी

Answer 2

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

Comments

हो सकता है कि एक इंटिमेट मैथ.रेड (px) वापस लौटाने लायक हो, क्योंकि अधिकांश तरीके एक पूर्णांक मान की उम्मीद करते हैं

— राज लबाना

@ मुहम्मदबाबर ऐसा इसलिए है क्योंकि 160 डीपीआई (mdpi) आधारभूत इच्छा है जिसमें से अन्य घनत्वों की गणना की जाती है। उदाहरण के लिए एचडीपीआई को 1.5x mdpi का घनत्व माना जाता है जो वास्तव में 240 डीपीआई कहने का एक और तरीका है। सभी घनत्व के लिए नीचे Zsolt Safrany का उत्तर देखें।

— स्टीफन

@TomTasche: Resource.getSystem()(जोर देने के लिए ) डॉक्स से : "एक वैश्विक साझा संसाधन ऑब्जेक्ट लौटाएं जो केवल सिस्टम रिसोर्सेस (कोई एप्लिकेशन रिसोर्सेस) तक पहुंच प्रदान करता है, और वर्तमान स्क्रीन के लिए कॉन्फ़िगर नहीं किया गया है ( आयाम इकाइयों का उपयोग नहीं कर सकता है , नहीं बदलता है) अभिविन्यास पर आधारित है, आदि) "

— विक्की चिजवानी

डेवलपर के पास मूल्य को छत / मंजिल करने का विकल्प है। डेवलपर को नियंत्रण देना बेहतर है।

— मुहम्मद नबील आरिफ

मैं डेवलपर कीDisplayMetrics.DENSITY_DEFAULT बजाय सिफारिश 160f

— करूंगा ।android.com

Answer 3

अधिमानतः एक 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;
}

Comments

यह सभी उपकरणों पर काम नहीं करता है! इस जवाब का परिणाम बनाम कि TypeedValue.applyDimension का उपयोग करना OnePlus 3T पर समान नहीं है (शायद इसलिए कि OnePlus के पास ओएस में निर्मित कस्टम स्केलिंग है)। TypedValue.applyDimension का उपयोग करने से उपकरणों में लगातार व्यवहार होता है।

— बेन डी ला हाय

Answer 4

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

density बराबरी

• .75पर ldpi( 120डीपीआई)
• 1.0पर mdpi( 160डीपीआई; आधार रेखा)
• 1.5पर hdpi( 240डीपीआई)
• 2.0पर xhdpi( 320डीपीआई)
• 3.0पर xxhdpi( 480डीपीआई)
• 4.0पर xxxhdpi( 640डीपीआई)

डीपीआई मूल्यों के साथ खेलने के लिए इस ऑनलाइन कनवर्टर का उपयोग करें ।

संपादित करें: ऐसा लगता है कि dpiबाल्टी और के बीच कोई 1: 1 संबंध नहीं है density। ऐसा लगता है कि Nexus 5Xजा रहा xxhdpiहै (के बजाय ) का densityमूल्य है । डिवाइस मेट्रिक्स में अपने लिए देखें ।2.6253

Comments

"ऐसा लगता है कि Nexus 5X xxhdpi होने का घनत्व 2.6 है (3 के बजाय)" - तकनीकी रूप से Nexus 5X 420dpi है और Nexus 6 / 6P 560dpi है, न ही मानक हैंडसेट में से एक में सीधे भूमि, जैसे। Nexus 7 tvdpi (213dpi) के साथ। तो xxdpi और xxxhdpi के रूप में उन लोगों को सूचीबद्ध करने वाली साइट एक फ़ेस है। आपका चार्ट सही है, और वे उपकरण अपने "विशेष" डीपीआई बाल्टी के आधार पर ठीक से मापेंगे।

— स्टीवन बाईले सेप

Answer 5

आप इसका उपयोग कर सकते हैं .. बिना संदर्भ के

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

जैसा कि @Stan ने उल्लेख किया है .. इस दृष्टिकोण का उपयोग करके समस्या का कारण हो सकता है अगर सिस्टम घनत्व में परिवर्तन करता है। तो उस के बारे में पता होना!

व्यक्तिगत रूप से मैं ऐसा करने के लिए प्रसंग का उपयोग कर रहा हूं। यह सिर्फ एक और दृष्टिकोण है जिसे मैं आपके साथ साझा करना चाहता था

Comments

आप इसका उपयोग नहीं करना चाहेंगे। गेटसिस्टम के लिए दस्तावेज़ीकरण () - "एक वैश्विक साझा संसाधन ऑब्जेक्ट लौटाएं जो केवल सिस्टम संसाधनों (कोई एप्लिकेशन संसाधन) तक पहुंच प्रदान करता है, और वर्तमान स्क्रीन के लिए कॉन्फ़िगर नहीं किया गया है (आयाम इकाइयों का उपयोग नहीं कर सकता है, अभिविन्यास, आदि के आधार पर परिवर्तित नहीं होता है) । "

— स्टेन

यह कहते हुए कि @Stan क्या कह रहा है: यह खतरनाक है और आपको इसका उपयोग नहीं करना चाहिए, विशेषकर अब जब डिवाइस फॉर्म कारक इतने जटिल होते जा रहे हैं।

— साकेत

Answer 6

यदि आप एक्सएमएल के आयामों का उपयोग कर सकते हैं तो यह बहुत सरल है!

अपने में res/values/dimens.xml:

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

फिर आपके जावा में:

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

Comments

चूँकि px से dp स्क्रीन डेंसिटी पर निर्भर करता है, मुझे नहीं पता कि ओपी को पहली बार में 120 कैसे मिले, जब तक कि उसने सभी अलग-अलग स्क्रीन साइज पर px से dp मेथड टेस्ट नहीं किया।

— जॉन ६१५

Answer 7

Android विकास गाइड के अनुसार:

px = dp * (dpi / 160)

लेकिन अक्सर आप चाहते हैं कि जब आप पिक्सेल में बताए गए डिज़ाइन को प्राप्त करते हैं, तो आप इसे दूसरे तरीके से कर सकते हैं। इसलिए:

dp = px / (dpi / 160)

यदि आप 240dpi डिवाइस पर हैं, तो यह अनुपात 1.5 है (जैसा कि पहले कहा गया है), इसलिए इसका मतलब है कि 60px आइकन एप्लिकेशन में 40dp के बराबर है।

Comments

सिंधु, आप यहाँ डेवलपर .android.com/guide/practices/… और डेवलपर

— सच्चिदानंद

160 निरंतर है, बिस्तर का जवाब है

— user25

@ user25 वास्तव में महान जवाब। क्या आपने Android स्क्रीन पर कोई डॉक्स नहीं पढ़ा है? एंड्रॉइड स्क्रीन घनत्व के बारे में बात करते समय 160 पूरे स्थान पर एक आम स्थिरांक है। डॉक्स से उद्धरण: "मध्यम-घनत्व (mdpi) स्क्रीन (~ 160dpi)। (यह आधारभूत घनत्व है)"। चलो, यार

— mykolaj

Answer 8

बिना Context, सुरुचिपूर्ण स्थिर तरीके:

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

Comments

Resources.getSystem()javadoc का कहना है "एक वैश्विक साझा संसाधन ऑब्जेक्ट लौटाएं जो केवल सिस्टम संसाधनों (कोई एप्लिकेशन संसाधन) तक पहुंच प्रदान करता है, और वर्तमान स्क्रीन के लिए कॉन्फ़िगर नहीं किया गया है (आयाम इकाइयों का उपयोग नहीं कर सकता है, अभिविन्यास, आदि के आधार पर परिवर्तित नहीं होता है)।" यह बहुत कुछ कहता है कि आपको यह नहीं करना चाहिए भले ही यह किसी भी तरह से काम करता हो।

— ऑस्टिन महोनी

मैंने अभी हाल ही में @ AustynMahoney की टिप्पणी पढ़ी और महसूस किया कि यह उत्तर उतना महान नहीं है जितना मैंने मूल रूप से सोचा था, लेकिन SO ने मुझे मेरे अपवित्र होने नहीं दिया ! अरे!

— विक्की चिजवानी 21

Answer 9

के लिये DP to Pixel

में एक मूल्य बनाएँ dimens.xml

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

उस मान को इस pixelरूप में प्राप्त करें :

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

Answer 10

इसलिए आप निम्न सूत्र का उपयोग 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);
}

Comments

यह dp को पिक्सेल में रूपांतरित करता है लेकिन आपने अपना तरीका बताया है convertToDp।

— क्वर्टी जूल

+ 0.5f यहाँ समझाया गया है -> developer.android.com/guide/practices/… । इसका उपयोग निकटतम पूर्णांक तक गोल करने के लिए किया जाता है।

— Bae

एकमात्र सही उत्तर। आप स्रोत डेवलपर

— ।android.com

web.archive.org/web/20140808234241/http://developer.android.com/ ... एक लिंक के लिए जो अभी भी प्रश्न में सामग्री है

— caw

Answer 11

Kotlin का उपयोग करने वाले किसी के लिए:

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

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

उपयोग:

64.toPx
32.toDp

Comments

Resource.getSystem () के लिए डॉक्स से: "एक वैश्विक साझा संसाधन ऑब्जेक्ट लौटाएं जो केवल सिस्टम संसाधनों (कोई एप्लिकेशन संसाधन) तक पहुंच प्रदान करता है, और वर्तमान स्क्रीन के लिए कॉन्फ़िगर नहीं किया गया है (आयाम इकाइयों का उपयोग नहीं कर सकता है, पर आधारित परिवर्तन नहीं होता है) अभिविन्यास, आदि) "

— HendraWD

@ HendraWD डॉक्स भ्रामक हो सकते हैं, जिस आयाम इकाई का उल्लेख किया जा रहा है वह आपके एप्लिकेशन स्तर डिमेंस संसाधन है। displayMetrics एक एप्लिकेशन स्तर संसाधन नहीं है। यह एक सिस्टम संसाधन है और यह सही मान देता है। यह कोड मेरे सभी प्रोडक्ट ऐप्स पर ठीक काम कर रहा है। कभी कोई मुद्दा नहीं था।

— 15

Answer 12

Android SDK में एक डिफ़ॉल्ट उपयोग है: http://developer.android.com/reference/android/util/TypedVideue.html

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

Comments

आपको इसका उपयोग करना चाहिए। बोनस के रूप में यह एसपी भी करेगा।

— मार्क रेनॉफ

resultPixइंट का प्रकार होना चाहिए। int resultPix = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,getResources().getDisplayMetrics())

— वोवहॉस्ट

Answer 13

कोटलिन-एक्सटेंशन का उपयोग करना बेहतर बनाता है

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

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

अपडेट करें:

वैश्विक साझा संसाधनोंdisplayMetrics का हिस्सा होने के कारण हम इसका उपयोग कर सकते हैंResources.getSystem()

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

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

Comments

आप इसे Int के विस्तार के रूप में क्यों जोड़ेंगे, जिम्मेदारी को Int प्रकार के साथ कुछ भी नहीं करना है।

— htafoya

Answer 14

यह आपको पिक्सेल में रूपांतरण dp देना चाहिए:

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

यह आपको रूपांतरण पिक्सेल को dp में देना चाहिए:

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

Answer 15

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

जावा

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

Answer 16

शायद सबसे अच्छा तरीका है अगर आपके पास मूल्यों / डिमेन के अंदर आयाम है, आयाम को सीधे getDimension () विधि से प्राप्त करना है, तो यह आपको पहले से ही पिक्सेल मूल्य में परिवर्तित आयाम वापस कर देगा।

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

बस बेहतर यह समझाने के लिए,

getDimension(int resourceId) 

पहले से ही पिक्सेल के रूप में परिवर्तित आयाम ए फ़्लोट में वापस आ जाएगा।

getDimensionPixelSize(int resourceId)

वही लौटेगा लेकिन int के लिए छोटा, इसलिए AN INTEGER है।

Android संदर्भ देखें

Answer 17

Dp को पिक्सेल में बदलने के लिए।

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

पिक्सेल को dp में बदलने के लिए।

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

जहाँ संसाधन संदर्भ है ।getResources ()।

Comments

उत्तर गलत है, क्योंकि आप पिक्सल को डीपी में परिवर्तित नहीं कर रहे हैं - आप पिक्सल को पिक्सल में परिवर्तित कर रहे हैं!

— यारोस्लाव

Px2dp गलत है - पिक्सेल में समान मान लौटाएगा।

— नैटारियो

Answer 18

इस तरह:

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

प्रसंग पर निर्भर, फ्लोट मूल्य, स्थिर विधि लौटें

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

Answer 19

कोटलिन के एक्सटेंशन फ़ंक्शन का उपयोग करके अधिक सुरुचिपूर्ण दृष्टिकोण

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

उपयोग:

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

Comments

यहां एक्सटेंशन के उपयोग से प्यार है। मैंने फ़ंक्शन को "कन्वर्ट" के रूप में पढ़ा है function nameजो मुझे एहसास है कि इस मामले में पीछे है। प्रत्येक फ़ंक्शन के इरादे को स्पष्ट करने के लिए, क्रमशः dpToPx और pxToDp को पढ़ने के लिए फ़ंक्शन के नाम अपडेट किए जा सकते हैं।

— मैक्सवेल

Resource.getSystem () के लिए डॉक्स से: "एक वैश्विक साझा संसाधन ऑब्जेक्ट लौटाएं जो केवल सिस्टम संसाधनों (कोई एप्लिकेशन संसाधन) तक पहुंच प्रदान करता है, और वर्तमान स्क्रीन के लिए कॉन्फ़िगर नहीं किया गया है (आयाम इकाइयों का उपयोग नहीं कर सकता है, पर आधारित परिवर्तन नहीं होता है) अभिविन्यास, आदि) "

— HendraWD

Answer 20

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

Comments

क्या यह वैसा ही नहीं है जैसा कि इस प्रश्न के कई अन्य उत्तरों में शामिल है?

— TZHX

Answer 21

यदि आप एक प्रदर्शन महत्वपूर्ण अनुप्रयोग विकसित कर रहे हैं, तो कृपया निम्नलिखित अनुकूलित वर्ग पर विचार करें:

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

Comments

यह केवल तभी बनाता है जब आप रूपांतरण वास्तव में अक्सर करते हैं। मेरे मामले में मैं करता हूं।

— पावेल

160f क्या है? आप इसका उपयोग क्यों करते हैं, यह 160 क्यों है?

— डेफिनेरा

160 => 160 डीपीआई और यह सूत्र के कारण उपायों को परिवर्तित करने के लिए है

— xAqweRx

Answer 22

टाइप करने के लिए पिक्सल में कनवर्ट करने के लिए टाइप करें ।

जैसा कि प्रलेखन में उल्लेख किया गया है: गतिशील रूप से टाइप किए गए डेटा मूल्य के लिए कंटेनर।

और applyDimension विधि का उपयोग करें :

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

जो निम्न की तरह अपने अंतिम फ़्लोटिंग पॉइंट मान के लिए एक अनपैक्ड कॉम्प्लेक्स डेटा वैल्यू को धारण करता है:

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

उम्मीद है की वो मदद करदे ।

Answer 23

यह मेरे लिए कैसे काम करता है:

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

आप चौड़ाई के लिए भी ऐसा कर सकते हैं।

Answer 24

ऊपर बहुत सारे महान समाधान। हालाँकि, मुझे जो सबसे अच्छा समाधान मिला वह है Google का डिज़ाइन:

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

Answer 25

जैसे ही आप पिक्सल करेंगे आपको डीपी का उपयोग करना चाहिए। बस इतना ही वे हैं; स्वतंत्र पिक्सेल प्रदर्शित करें। एक मध्यम घनत्व स्क्रीन पर समान संख्याओं का उपयोग करें, और उच्च घनत्व स्क्रीन पर आकार जादुई रूप से सही होगा।

हालाँकि, ऐसा लगता है कि आपको अपने लेआउट डिज़ाइन में fill_parent विकल्प क्या चाहिए। जब आप अपने दृश्य या नियंत्रण को मूल कंटेनर में सभी शेष आकार तक विस्तारित करना चाहते हैं, तो fill_parent का उपयोग करें।

Comments

वास्तव में मेरी समस्या यह है कि मेरा आवेदन उच्च घनत्व स्क्रीन के लिए कोडित है और अब इसे कम घनत्व स्क्रीन में

— बदलने की आवश्यकता है

मध्यम घनत्व स्क्रीन के लिए अपने पिक्सेल को संशोधित करें (आप एमुलेटर में एक मध्यम घनत्व स्क्रीन सेट कर सकते हैं) और पिक्सेल को डीपी से बदल दें। हालाँकि, अधिक लचीले अनुप्रयोगों को fill_parent और कई लेआउट का उपयोग करके बनाया जा सकता है।

— माइकल लोमैन

अंत में, मेरे पास मैन्युअल रूप से dp में सभी px को बदलने के अलावा कोई विकल्प नहीं था .. :(

— Indhu

कम से कम अगली बार आप सबसे पहले डीपी का उपयोग करेंगे और कुछ भी नहीं बदलना होगा :), हालांकि लेआउट का उपयोग करना संभव होना चाहिए जिसमें अधिकांश चीजों के लिए पूर्ण स्थिति की आवश्यकता नहीं होती है।

— माइकल लोमैन

चूंकि यह मेरा पहला ऐप था .. मैंने यह गलती की है ... मैं इसे फिर कभी नहीं

— करूंगा

Answer 26

PXऔर DPअलग हैं, लेकिन समान हैं।

DPवह रिज़ॉल्यूशन है जब आप केवल स्क्रीन के भौतिक आकार को दर्शाते हैं। जब आप इसका उपयोग करते हैं तो DPयह आपके लेआउट को विभिन्न pixelघनत्व के साथ अन्य समान आकार के स्क्रीन पर स्केल करेगा ।

कभी-कभी आप वास्तव में चाहते हैं pixels, और जब आप कोड में आयामों के साथ व्यवहार करते हैं तो आप हमेशा वास्तविक के साथ व्यवहार करते हैं pixels, जब तक कि आप उन्हें परिवर्तित नहीं करते।

तो एक Android डिवाइस, सामान्य आकार पर hdpiस्क्रीन, 800x480 is 533x320में DP(मेरा मानना है कि)। परिवर्तित करने के लिए DPमें pixels /1.5, वापस कन्वर्ट करने के लिए *1.5। यह केवल एक स्क्रीन आकार के लिए है और dpi, यह डिजाइन के आधार पर बदल जाएगा। हमारे कलाकार pixelsहालांकि मुझे देते हैं और मैं DPउपरोक्त 1.5समीकरण के साथ परिवर्तित होता हूं ।

Answer 27

यदि आप पूर्णांक मान चाहते हैं, तो Math.round () का उपयोग करके निकटतम पूर्णांक में फ़्लोट को राउंड किया जाएगा।

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

Answer 28

यह मेरे लिए काम करता है (C #):

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

Comments

इस प्रश्न का उत्तर नहीं है लेकिन C # के लिए यह काम करता है। धन्यवाद

— येकमर सिमसेक

Answer 29

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
}

जावा

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

Answer 30

सबसे अच्छा जवाब एंड्रॉइड फ्रेमवर्क से ही आता है: बस इस समानता का उपयोग करें ...

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

(dp को px में कनवर्ट करता है)