एंड्रॉइड में रनटाइम पर dp या डिप के संदर्भ में स्क्रीन की चौड़ाई कैसे निर्धारित करें?

Question

मुझे डिप / dp (जावा फ़ाइलों में) का उपयोग करके एंड्रॉइड विजेट के लेआउट को कोड करने की आवश्यकता है। यदि मैं कोड रनटाइम पर

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

यह पिक्सेल (px) में स्क्रीन की चौड़ाई लौटाता है। इसे dp में बदलने के लिए, मैंने कोड किया:

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

यह सही उत्तर नहीं दे रहा है। मैंने WVGA800 का एमुलेटर बनाया जिसका स्क्रीन रिज़ॉल्यूशन 480 बाई 800 है। जब एमुलेटर चलाते हैं और कोड को पिक्सेल और डीपी के मूल्यों को प्रिंट करते हैं, तो यह दोनों में 320 आया। यह एमुलेटर 240 डीपीआई है जिसका स्केल फैक्टर 0.75 होगा।

Answer 1

इसे इस्तेमाल करे

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;

या

धन्यवाद @ Tomáš Hubálek

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

Comments

क्यों जरूरी है WindowManager? इस कोड के बारे में क्या? DisplayMetrics displayMetrics = resource.getDisplayMetrics (); फ्लोट स्क्रीनवाइटडेप = displayMetrics.widthPixels / displayMetrics.d घनत्व;

— टॉमस हबलेक

यह मेरे लिए बहुत उच्च घनत्व स्क्रीन का उपयोग करके काम नहीं किया। यह ऐसा था जैसे इसे केवल स्क्रीन का एक छोटा हिस्सा मिला हो। इस समाधान ने मेरे लिए काम किया: stackoverflow.com/a/18712361/956975 डिस्प्ले डिस्प्ले = getWindowager ()। GetDefaultDisplay (); बिंदु का आकार = नया बिंदु (); display.getSize (आकार); int चौड़ाई = size.x; int height = size.y;

— मारिएनके

@dsdsdsdsd: संदर्भ प्रसंग वर्ग का कोई उदाहरण है। सबसे विशेष रूप से, गतिविधि प्रसंग का एक उप वर्ग है (इसलिए किसी गतिविधि में इसका उपयोग करें, और getActivity () फ्रैगमेंट में)। आवेदन और सेवा भी प्रसंग की उप कक्षाएं हैं।

— फ़्राँस्वा POYER

Answer 2

मैं Google के इस प्रश्न पर लड़खड़ा गया, और बाद में मुझे API> = 13 के लिए एक आसान समाधान वैध लगा।

भविष्य के संदर्भों के लिए:

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.

कॉन्फ़िगरेशन क्लास संदर्भ देखें

संपादित करें: जैसा कि निक बैकोइयानु ने उल्लेख किया है, यह स्क्रीन की प्रयोग करने योग्य चौड़ाई / ऊँचाई (जो अधिकांश उपयोगों में दिलचस्प होनी चाहिए) देता है। यदि आपको वास्तविक प्रदर्शन आयामों की आवश्यकता है तो शीर्ष उत्तर पर रहें।

Comments

कॉन्फ़िगरेशन की स्क्रीनव्यूडीडीपी / स्क्रीनहाइटडैप बनाम डिस्प्लेमैट्रिक्स चौड़ाईपिक्सल्स / हाइटपिक्सल का उपयोग करने के बीच एक महत्वपूर्ण अंतर यह है कि कॉन्फ़िगरेशन प्रदर्शन योग्य प्रदर्शन आयामों (स्थिति बार आदि को घटाता है ), जबकि डिस्प्लेमेट्रिक्स पूर्ण स्क्रीन आयाम देता है।

— निक बैकोयानू

यह केवल एपीआई स्तर 13 के लिए और ऊपर है

— ओनो

@ NickBaicoianu की टिप्पणी में जोड़ने के लिए, दोनों getConfiguration () और getDisplayMetrics () विधियाँ मल्टी-विंडो मोड में काम करती हैं। यानी आकार खिड़की के दर्शाते हैं, न कि स्क्रीन के।

— nmw

Answer 3

आप 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

दूसरे शब्दों में, यदि आप पोर्ट्रेट मोड में 160dip के बराबर चौड़ाई वाले लेआउट को डिजाइन करते हैं, तो यह सभी ldpi / mdpi / hdpi डिवाइसों पर स्क्रीन का आधा हिस्सा होगा (गोलियों को छोड़कर, मुझे लगता है)

Comments

आपने जो उत्तर दिया है, वह मेरे सवाल के पीछे का तर्क है। मुझे यह समझ आ गया। मुझे इसे जावा में कैसे कोडित करना चाहिए ताकि रनटाइम पर स्क्रीन रिज़ॉल्यूशन जो भी हो, सही dpi चौड़ाई को कोड द्वारा चुना जाए?

— खुशबू

आशा है कि मैं इसे इस बार ठीक कर लूंगा :) DisplayMetrics outMetrics = null; getWindowManager().getDefaultDisplay().getMetrics(outMetrics);गतिविधि के भीतर उपयोग करूंगा । फिर, outMetrics.densityआपको वर्तमान डिवाइस का पैमाना कारक देगा, जैसा कि डॉक्स

— Mykhailo Gaidai

Answer 4

इसके बजाय इसका उपयोग कैसे करें?

final DisplayMetrics displayMetrics=getResources().getDisplayMetrics();
final float screenWidthInDp=displayMetrics.widthPixels/displayMetrics.density;
final float screenHeightInDp=displayMetrics.heightPixels/displayMetrics.density;

Answer 5

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;

Comments

कुछ स्पष्टीकरण देने पर विचार करें

— bigbounty

Answer 6

कोटलिन में उत्तर:

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

Answer 7

कोटलिन के लिए सरलीकृत:

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

Answer 8

कुछ अच्छी सजावट के साथ डीपी के संदर्भ में स्क्रीन की चौड़ाई और ऊँचाई प्राप्त करें:

चरण 1: इंटरफ़ेस बनाएँ

public interface ScreenInterface {

   float getWidth();

   float getHeight();

}

चरण 2: कार्यान्वयनकर्ता वर्ग बनाएं

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

चरण 3: गतिविधि में चौड़ाई और ऊंचाई प्राप्त करें:

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

Comments

क्या यह पिक्सेल या dp में ऊँचाई और चौड़ाई लौटाता है?

— तस्लीम ओसेनी

जैसा कि कहा जाता है। घनत्व यही कारण है कि इसका आपको dp में

— अली अज़ाज़ आलम

मुझे नहीं लगता कि एक सरल कार्य को हल करने के लिए अपने ऐप में कोड के टन जोड़ना एक अच्छा विचार है

— रुस्लान बिर्ज़ोव

सर यह आप पर निर्भर है कि कक्षा को लागू करें या सीधे इसे कोड करें। परिभाषित वर्ग से आप आसानी से प्रत्यक्ष कार्यान्वयन के लिए कोड निकाल सकते हैं।

— अली अज़ाज़ आलम

Answer 9

यदि आप अपनी स्क्रीन चौड़ाई के बारे में जानना चाहते हैं, तो आप बस अपने डेवलपर विकल्पों में "सबसे छोटी स्क्रीन चौड़ाई" खोज सकते हैं। आप इसे संपादित भी कर सकते हैं।

Answer 10

इसे इस्तेमाल करे:

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

Answer 11

आपकी समस्या एक अंतर को फ्लोट कास्टिंग के साथ है, सटीक खोना। आपको कारक के साथ गुणा करना चाहिए और विभाजन नहीं करना चाहिए।

यह करो:

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

Comments

यह उत्तर गलत है। से developer.android.com/guide/practices/... , पिक्सेल = dp * घनत्व।

— वंस-टर्नर