एंड्रॉइड में पिक्सल के रूप में स्क्रीन आयाम कैसे प्राप्त करें

Question

मैंने कुछ कस्टम तत्व बनाए हैं, और मैं उन्हें ऊपरी दाएं कोने में प्रोग्राम करना चाहता हूं (ऊपरी nकिनारे mसे पिक्सेल और दाएं किनारे से पिक्सेल)। इसलिए मुझे स्क्रीन की चौड़ाई और स्क्रीन की ऊंचाई प्राप्त करने की आवश्यकता है और फिर स्थिति निर्धारित करें:

int px = screenWidth - m;
int py = screenHeight - n;

मैं कैसे प्राप्त करूं screenWidthऔर screenHeightमुख्य गतिविधि में?

Comments

Px के बजाय dp का उपयोग करें। क्योंकि यह अन्य उपकरणों के साथ आपके लेआउट को विकृत कर देगा ..

— Jawad Zeb

GetResources ()। GetDisplayMetrics () द्वारा गुणा करने के लिए मत भूलना प्रदर्शन स्केलिंग के लिए खाते में घनत्व

— 16'14

यह साबित करता है कि सबसे अधिक मतदान का जवाब हमेशा सबसे अच्छा नहीं होता है (और बहुत से लोग दोहराने के लिए उत्तर दोहराते हैं)। GetSize और deprecated getWidth / getHeight कॉम्बो (त्रुटियों की अनदेखी) के बजाय, Balaji.K's का प्रयास करें getMetrics। अपने जवाब में निक की टिप्पणी getDisplayMetricsप्रणाली / स्थिति बार के आकार पर विचार करने के लिए भी समझाती है। इसके अलावा आप घनत्व का उपयोग कर सकते हैं क्योंकि jmaculate और LoungeKatt का सटीक मान बताया गया है : DisplayMetrics dm = getResources().getDisplayMetrics(); float fwidth = dm.density * dm.widthPixels;Android v2.2 (API 8) और v4.0 में अच्छे परिणाम और कोई त्रुटि / चेतावनी के साथ परीक्षण किया गया ।

— आर्मफूट

डिस्प्लेमेट्रिक्स डिस्प्लेमेट्रिक्स = नया डिस्प्लेमेट्रिक्स (); । getWindowManager () getDefaultDisplay () getMetrics (displaymetrics)। int height = displaymetrics.heightPixels; int चौड़ाई = displaymetrics.widthPixels;

— अज़हर

DisplayMetrics प्राप्त करने का दूसरा तरीका Resources.getSystem().getDisplayMetrics():। आपको Contextउन्हें प्राप्त करने की आवश्यकता नहीं होगी ।

— टैग

Answer 1

यदि आप पिक्सेल में प्रदर्शन आयामों का उपयोग करना चाहते हैं getSize:

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

यदि आप में नहीं हैं, Activityतो आप इसके Displayमाध्यम से डिफ़ॉल्ट प्राप्त कर सकते हैं WINDOW_SERVICE:

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

यदि आप एक खंड में हैं और यह काम करना चाहते हैं, तो गतिविधि का उपयोग करें ।indowManager (Xamarin.Android में) या getActivity ()। GetWindowManager () (जावा में)।

पहले getSize(एपीआई स्तर 13 में) पेश किया गया था, आप अब अपग्रेड किए गए तरीकों getWidthऔर getHeightतरीकों का उपयोग कर सकते हैं:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

हालांकि आप जिस उपयोग के मामले का वर्णन कर रहे हैं, उसके लिए लेआउट में एक मार्जिन / पैडिंग अधिक उपयुक्त लगती है।

दूसरा तरीका है: डिस्प्लेमेट्रिक्स

एक संरचना के बारे में सामान्य जानकारी का वर्णन करने वाली संरचना, जैसे कि उसका आकार, घनत्व और फ़ॉन्ट स्केलिंग। DisplayMetrics के सदस्यों तक पहुँचने के लिए, इस तरह से किसी ऑब्जेक्ट को इनिशियलाइज़ करें:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

हम इसके widthPixelsलिए जानकारी प्राप्त करने के लिए उपयोग कर सकते हैं :

"पिक्सेल में डिस्प्ले की निरपेक्ष चौड़ाई।"

उदाहरण:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

Comments

getWidth () या getSize ()? अगर मुझे API <13 के साथ-साथ API> 13 पर चलने के लिए मेरे ऐप की आवश्यकता हो तो मैं क्या उपयोग करूंगा?

— कैरल

कोशिश {display.getSize (आकार); चौड़ाई = size.x; ऊँचाई = size.y; } पकड़ (NoSuchMethodError e) {चौड़ाई = display.getWidth (); ऊँचाई = display.getHeight (); }

— अरनौद

मैं नहीं देखता कि आप try/catchइस तरह के चेक का उपयोग क्यों करना चाहते हैं ? बस if (android.os.Build.VERSION.SDK_INT >= 13)बिना किसी फेंके हुए अपवाद का उपयोग क्यों नहीं किया जाता है ? मैं try/catchएक सामान्य ऐप-फ्लो को बुरा अभ्यास मानता हूं ।

— पेट्रीक

@ ए-लाइव तब ऐप टूट जाएगा (लेकिन दुर्घटनाग्रस्त नहीं)। हम डेवलपर्स को एक नए ओएस संस्करण की पूर्व-जांच करनी चाहिए, लेकिन यह शायद एक समस्या को छिपाएगा। इस तर्क के साथ, किसी को कोशिश / पकड़ के साथ हर कुछ कोड लाइनों को घेरना चाहिए, जो कि मेरी राय में पहले से ही बताए गए बुरे व्यवहार हैं।

— पेट्रिक

क्या होगा यदि आप नेविगेशन बार और / या सूचना पट्टी को छोड़कर स्क्रीन आकार प्राप्त करना चाहते हैं

— Android डेवलपर

Answer 2

एक तरीका है:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();
int height = display.getHeight();

यह पदावनत है, और आपको इसके बजाय निम्नलिखित कोड का प्रयास करना चाहिए। कोड की पहली दो पंक्तियाँ आपको DisplayMetricsऑब्जेक्स देती हैं । इस ऑब्जेक्ट में फ़ील्ड शामिल हैं heightPixels, जैसे widthPixels।

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

int height = metrics.heightPixels;
int width = metrics.widthPixels;

Comments

ध्यान दें कि उपकरण के रोटेशन के आधार पर मैट्रिक्स (चौड़ाई, ऊंचाई) बदलते हैं।

— टोनी चैन

मेट्रिक्स प्रदर्शन के आकार को वापस कर देगा, लेकिन हनीकोम्ब और अप, आपकी गतिविधि में सिस्टम बार के कारण वापस आने की तुलना में कम जगह होगी।

— लड़का

@ यह आपके कार्यान्वयन पर निर्भर करता है। आप स्थिति पट्टी छिपा सकते हैं: requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow ()। setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);

— हागई एल

इस तरह से भी मौजूद है: getContext ()। GetResources ()। GetDisplayMetrics ()। widthPixels

— Nik

अंतिम फ्लोट स्केल = getResources ()। getDisplayMetrics ()। घनत्व; int चौड़ाई = (int) (मेट्रिक्स। उपलब्धता पिक्सल्स * स्केल + 0.5 एफ); - इस तरह से करते समय आपको डिवाइस के घनत्व का ध्यान रखना होगा।

— कार्ट

Answer 3

यह आपके प्रश्न का उत्तर नहीं दे सकता है, लेकिन यह जानना उपयोगी हो सकता है (जब मैं इस प्रश्न के लिए आया था तो मैं स्वयं इसकी तलाश कर रहा था) कि यदि आपको व्यू के आयाम की आवश्यकता है, लेकिन आपका कोड तब निष्पादित किया जा रहा है जब इसका लेआउट अभी तक निर्धारित नहीं किया गया है (उदाहरण के लिए onCreate()) आप एक के ViewTreeObserver.OnGlobalLayoutListenerसाथ सेटअप कर सकते हैं View.getViewTreeObserver().addOnGlobalLayoutListener()और संबंधित कोड डाल सकते हैं, जिसे वहां के आयाम की आवश्यकता है। श्रोता का कॉलबैक तब कहा जाएगा जब लेआउट बिछाया गया होगा।

Comments

या सिर्फ view.post लिखिए

— लुकास हैनसेक

view.post हालांकि काम करने की गारंटी नहीं है। यह सिर्फ एक वर्कअराउंड है।

— मर्सबियर

@marsbear यह कहाँ कहता View.post()है कि काम करने की गारंटी नहीं है? मैं उत्सुक हूं क्योंकि मैं लेआउट के बाद व्यू का आकार प्राप्त करने के लिए इस पद्धति पर भी भरोसा करता हूं और यह अविश्वसनीय था।

— टोनी चैन

@ टर्बो मैं यह कहता हूं: p हमने पहले उस वर्कअराउंड का उपयोग किया और यह अविश्वसनीय हो गया। यह वर्कअराउंड इस धारणा पर आधारित है, कि प्रारंभ में लेआउटिंग को प्रारंभ के रूप में एक ही UIThread टर्न के भीतर किया जाता है। इसलिए आप पोस्ट के माध्यम से अगले यूआई मोड़ से पहले चलाने के लिए अपने कोड को शेड्यूल कर सकते हैं (और ठीक हो सकते हैं)। यह पता चला कि लेआउटिंग कुछ परिस्थितियों में भी अधिक समय ले सकती है और पोस्ट कोड चलने पर दृश्य अभी भी लेआउट नहीं किया गया था। अब मैं क्या करता हूं कि व्यूक्राइबसर को onCreate में जोड़ दें और पहले onLayout के बाद इसे हटा दें। उस पहले onLayout के दौरान अपना सामान डालें।

— मार्सबियर

@ मार्सबियर से कोई फर्क नहीं पड़ता कि Viewआप किससे प्राप्त करते ViewTreeObserverहैं? या वे सभी एक ही साझा करते हैं?

— टोनी चैन

Answer 4

(2012 उत्तर, तारीख से बाहर हो सकता है) यदि आप पूर्व छत्ते का समर्थन करना चाहते हैं, तो आपको एपीआई 13. से पहले पिछड़े संगतता में डालना होगा।

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

बेशक हटाए गए तरीकों को अंततः सबसे हाल के एसडीके से बाहर ले जाया जाएगा, लेकिन जब हम अभी भी अपने अधिकांश उपयोगकर्ताओं पर भरोसा करते हैं, जिनके पास एंड्रॉइड 2.1, 2.2 और 2.3 है, तो यह वही है जो हमारे पास बचा हुआ है।

Comments

हाँ, यह 2012 में वापस आ गया था।

— digiphd

क्षमा करें, मुझे स्पष्ट करें कि मेरा क्या मतलब है। यह अत्यधिक संभावना नहीं है कि कोई भी एपीआई <14 का समर्थन करेगा 6/22/2015 के रूप में

— सुडोकू

Answer 5

मैंने हर संभव "समाधान" की असफल कोशिश की है और मैंने देखा है कि इलियट ह्यूजेस का "डेल्विक एक्सप्लोरर" ऐप हमेशा किसी भी एंड्रॉइड डिवाइस / ओएस संस्करण पर सही आयाम दिखाता है। मैं उनके ओपन सोर्स प्रोजेक्ट को देख रहा हूं जो यहां मिल सकते हैं: https://code.google.com/p/enh/

यहाँ सभी संबंधित कोड है:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

संपादित करें: थोड़ा बेहतर संस्करण (गैर-समर्थित ओएस संस्करण पर फायरिंग अपवादों से बचें):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

Comments

यह यहां एकमात्र पोस्ट है जो विंडो सजावट (स्टेटसबार / मेनू बार) को ध्यान में रखता है। मेरे लिए बहुत अच्छा काम किया।

— एंडी कोचरन

हालांकि, आपको व्यावसायिक तर्क आग अपवादों की अपेक्षा नहीं करनी चाहिए। अपवाद फायरिंग (पकड़े जाने पर भी) प्रदर्शन के लिए भयानक है। इसके अलावा आप जरूरत से ज्यादा काम कर रहे हैं अगर SDK_INT है> 13. इसके बजाय, आपको Build.VERSION.SDK_INT पर बस कुछ ifs जोड़ना चाहिए।

— एरिक बी

@ एरिक बी, मैं सहमत हूं। मैंने उन्नत संस्करण जोड़ा। फिर भी मैंने "एसडीके 1 के बाद से" भाग छोड़ दिया, बस मामले में कुछ गलत होने की कोशिश करता है / पकड़ लिया है (मैंने एंड्रॉइड में कई बुरी चीजें देखी हैं, खासकर जब आपको लगता है कि यह असंभव है कुछ गलत हो सकता है इसलिए मैं इसे सुरक्षित रखना पसंद करता हूं :)) । वैसे भी वहाँ बहुत अधिक उपरि नहीं होना चाहिए क्योंकि यह गणना केवल एक बार की जानी चाहिए (जैसे मानों को कुछ स्थिर विशेषताओं में रखा जा सकता है)।

— ड्रेगन मारजानोविव

ध्यान दें कि इस कोड को GPL v3 के तहत लाइसेंस प्राप्त है जिसके उत्पादन एप्लिकेशन में उपयोग के लिए निहितार्थ हैं।

— TalkLittle

GPL और परावर्तन पर निर्भर करता है, जो कि भविष्य के Android संस्करणों में मौजूद नहीं हो सकता है। Mhhh

— मिशेल

Answer 6

सबसे सरल तरीका:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 

Answer 7

एंड्रॉइड डिवाइसों के लिए स्टेटस बार की ऊंचाई तक पहुंचने के लिए, हम इसे प्राप्त करने के लिए एक प्रोग्रामेटिक तरीका पसंद करते हैं:

नमूना कोड

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

चर resultपिक्सेल में ऊँचाई देता है।

त्वरित पहुँच के लिए

की ऊंचाई के बारे में अधिक जानकारी के लिए Title bar, Navigation barऔर Content Viewकृपया Android डिवाइस स्क्रीन आकार पर देखें ।

Comments

मुझे जिस चीज की जरूरत थी! getResources().getDisplayMetrics().heightPixels + resultवास्तविक फुलस्क्रीन ऊंचाई देता है। ड्रेगन मार्जनोविच का जवाब भी काम करता है लेकिन मैं इसे बहुत छोटा और सरल समाधान पसंद करता हूं।

— मिशेल

यह दृष्टिकोण एंड्रॉइड मार्शमैलो के रूप में पुराना है। स्टेटस बार की ऊंचाई डिवाइस या एंड्रॉइड वर्जन से बदल सकती है। बेहतर उपयोग OnApplyWindowInsetsListener।

— हेनरिक

Answer 8

पहले दृश्य देखें (उदाहरण के लिए findViewById()) और फिर आप दृश्य पर ही getWidth () का उपयोग कर सकते हैं ।

Comments

यह वास्तव में है कि कैसे प्रलेखन आपको यह करने के लिए कहता है ... लेकिन यदि आप एक दृश्य का उपयोग नहीं कर रहे हैं तो यह थोड़े व्यर्थ है। आप कुछ और उपयोग कर सकते हैं, उदाहरण के लिए mglsurfaceview।

— gcb

यह बेहतर है क्योंकि अभिभावक दृश्य प्रदर्शन का आकार नहीं हो सकता है। लेकिन यह सुनिश्चित कर लें कि यह उस बिंदु पर किया जाता है जहां आप जिस आकार को क्वेरी कर रहे हैं, वह पहले से ही बाहर रखा गया है, जो आमतौर पर ऑनक्रिएट () के अंदर नहीं होगा। आप onWindowFocusChanged (बूलियन hasFocus) से एक कस्टम कॉलबैक का उपयोग कर सकते हैं, जिसे सभी विचारों को मापने के बाद कॉल किया जाएगा और इसी तरह, यह सुनिश्चित करने के लिए कि आप इसे देखने के लिए गलत आयाम प्राप्त नहीं करेंगे जो आप इसे पसंद कर रहे हैं ...

— डोरी

Answer 9

मेरे पास दो कार्य हैं, एक संदर्भ भेजने के लिए और दूसरा पिक्सेल में ऊँचाई और चौड़ाई प्राप्त करने के लिए:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

तथा

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}

Comments

@SuppressLint("NewApi")संकलन करने में सक्षम होने के लिए आपको फ़ंक्शन हस्ताक्षर के ठीक ऊपर जोड़ना होगा।

— आदिल मलिक

मुझे लगता है कि एपीआई में अलग-अलग कॉल के बजाय एक बार में ऊंचाई और चौड़ाई प्राप्त करना बेहतर है क्योंकि अन्यथा वे सिंक से बाहर हो सकते हैं। यदि आपका कोड चल रहा है तो स्क्रीन ओरिएंटेशन बदल रहा है तो ऐसा हो सकता है।

— सैम

Answer 10

XML का उपयोग करते हुए गतिशील रूप से स्केलिंग के लिए एक विशेषता है, जिसे "एंड्रॉइड: लेआउट_वेट" कहा जाता है

नीचे दिए गए उदाहरण, इस थ्रेड पर सिनिक की प्रतिक्रिया से संशोधित , एक बटन दिखाता है जो 75% स्क्रीन (वजन = .25) लेता है और एक पाठ दृश्य स्क्रीन के शेष 25% (वजन = .75) को लेता है।

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>

Answer 11

यह वह कोड है जो मैं कार्य के लिए उपयोग करता हूं:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

पर्याप्त साफ लगता है और फिर भी, डिप्रैशन का ख्याल रखता है।

Answer 12

क्या यह ज्यादा बेहतर समाधान नहीं है? डिसप्लेमेट्रिक्स आपकी जरूरत की हर चीज के साथ आता है और एपीआई 1 से काम करता है।

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

आप getRealMetrics का उपयोग करके वास्तविक प्रदर्शन (स्क्रीन डिकर्स, जैसे स्टेटस बार या सॉफ़्टवेयर नेविगेशन बार) भी प्राप्त कर सकते हैं , लेकिन यह केवल 17+ पर काम करता है।

क्या मैं कुछ भूल रहा हूँ?

Comments

यह ऑन-स्क्रीन नियंत्रण (जैसे कि टैबलेट या नेक्सस डिवाइस पर) के लिए जगह नहीं घटा रहा है। इसके अलावा, मैं अपने 10 "टैबलेट पर एक अलग मूल्य (750 बनाम 800) प्राप्त करता हूं, इस पर निर्भर करता है कि क्या गणना सक्रिय होने पर गतिविधि सक्रिय है। लेकिन मेरे उद्देश्यों के लिए, यह ठीक से अधिक है। धन्यवाद!

— स्टीवन एल

Answer 13

बस फ्रांसेस्को के जवाब में जोड़ रहे हैं। अन्य प्रेक्षक जो अधिक उपयुक्त है, यदि आप विंडो में स्थान या स्क्रीन में स्थान का पता लगाना चाहते हैं तो ViewTreeObserver.OnPreDrawListener () है

यह एक दृश्य के अन्य गुणों को खोजने के लिए भी इस्तेमाल किया जा सकता है जो कि ऑनक्रिएट () समय पर अज्ञात है जैसे स्क्रॉल की गई स्थिति, स्केल की गई स्थिति।

Answer 14

गतिविधि में निम्नलिखित कोड का उपयोग करना।

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

Answer 15

स्क्रीन की चौड़ाई और ऊँचाई ज्ञात करें:

width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();

इसका उपयोग करके, हम नवीनतम और ऊपर एसडीके 13 प्राप्त कर सकते हैं।

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}

Answer 16

DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Answer 17

मैंने पाया यह चाल है।

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

Comments

कूलोड, लेकिन सोर्सकोड में इस पद्धति के बारे में एक डरावनी बात है: यह टिप्पणी

— नोर्बर्ट

Answer 18

कहने की आवश्यकता है, कि यदि आप में नहीं हैं Activity, लेकिन View(या Viewआपके दायरे में प्रकार का चर है ), उपयोग करने की आवश्यकता नहीं हैWINDOW_SERVICE । तब आप कम से कम दो तरीकों का उपयोग कर सकते हैं।

प्रथम:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

दूसरा:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

यह सब विधियाँ जिन्हें हम यहाँ कहते हैं, पदावनत नहीं है।

Answer 19

public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}

Answer 20

स्क्रीन आयाम प्राप्त करने के लिए प्रदर्शन मेट्रिसेस का उपयोग करें

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

पिक्सल में ऊंचाई और चौड़ाई प्राप्त करें

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;

Answer 21

यह ओपी के लिए एक जवाब नहीं है, क्योंकि वह वास्तविक पिक्सल में प्रदर्शन आयाम चाहते थे। मुझे "डिवाइस-इंडिपेंडेंट-पिक्सल" में आयाम चाहिए थे, और यहाँ से जवाब एक साथ डालकर https://stackoverflow.com/a/17880012/253938 और यहाँ https://stackoverflow.com/a/6656774/253938 आया। इसके साथ:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);

Answer 22

आप ऊंचाई का उपयोग कर प्राप्त कर सकते हैं :

getResources().getDisplayMetrics().heightPixels;

और चौड़ाई का उपयोग कर आकार

getResources().getDisplayMetrics().widthPixels; 

Answer 23

DisplayMetrics (API 1) का उपयोग करते हुए ऐसा करने के लिए एक गैर-वंचित तरीका है, जो प्रयास / कैच मैस से बचता है:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;

Answer 24

मैं getSize कोड को इस तरह लपेटूंगा:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}

Comments

यह एंड्रॉइड 4.0 (एपीआई 14) चलाने वाले एमुलेटर पर क्रैश होता है।

— jww

Answer 25

जो स्टेटस बार और एक्शन बार के बिना प्रयोग करने योग्य स्क्रीन आयाम की खोज कर रहा है (स्वप्निल के उत्तर के लिए भी धन्यवाद)

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}

Answer 26

पहले XML फ़ाइल लोड करें और फिर यह कोड लिखें:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

अपने स्क्रीन रिज़ॉल्यूशन के अनुसार चौड़ाई और ऊंचाई दिखाएं।

Answer 27

नीचे दिए गए तरीकों का पालन करें:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}

Answer 28

Kotlin

fun getScreenHeight(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.heightPixels
}

fun getScreenWidth(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.widthPixels
}

Answer 29

ऐसे समय होते हैं जब आपको किसी गतिविधि के चालू होने पर लेआउट के लिए उपलब्ध स्थान के सटीक आयामों को जानने की आवश्यकता होती है। कुछ विचार के बाद मैंने इसे करने के तरीके पर काम किया।

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

यदि किसी कारण से आप Android मेनिफ़ेस्ट में कोई अन्य गतिविधि नहीं जोड़ना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    

Comments

जाहिर है, आप बंडल में ऊंचाई भी वापस कर सकते हैं।

— स्टीव वार्निंग

Answer 30

यदि आप WindowManagers, Points, या Displays का ओवरहेड नहीं चाहते हैं, तो आप अपने XML में सबसे ऊपरी दृश्य आइटम की ऊँचाई और चौड़ाई की विशेषताओं को पकड़ सकते हैं, बशर्ते कि इसकी ऊँचाई और चौड़ाई match_parent पर सेट हो। (यह तब तक सच है जब तक आपका लेआउट पूरी स्क्रीन को ले लेता है।)

उदाहरण के लिए, यदि आपका XML कुछ इस तरह से शुरू होता है:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

फिर findViewById(R.id.entireLayout).getWidth()स्क्रीन की चौड़ाई findViewById(R.id.entireLayout).getHeight()वापस कर देगा और स्क्रीन की ऊँचाई वापस कर देगा।