Android में स्क्रीन की चौड़ाई और ऊँचाई प्राप्त करें

Question

मैं स्क्रीन की चौड़ाई और ऊंचाई कैसे प्राप्त कर सकता हूं और इस मूल्य का उपयोग इसमें कर सकता हूं:

@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
    Log.e(TAG, "onMeasure" + widthSpecId);
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
        game.findViewById(R.id.flag).getHeight());
}

Comments

देखें: stackoverflow.com/questions/1016896/…

— Tate

Answer 1

इस कोड का उपयोग करके, आप रनटाइम डिस्प्ले की चौड़ाई और ऊँचाई प्राप्त कर सकते हैं:

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

---

एक दृश्य में आपको ऐसा कुछ करने की आवश्यकता है:

((Activity) getContext()).getWindowManager()
                         .getDefaultDisplay()
                         .getMetrics(displayMetrics);

---

कुछ परिदृश्यों में, जहां उपकरणों में नेविगेशन बार होता है, आपको रनटाइम पर जांच करनी होगी:

public boolean showNavigationBar(Resources resources)
{
    int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
    return id > 0 && resources.getBoolean(id);
}

यदि डिवाइस में नेविगेशन बार है, तो उसकी ऊंचाई को गिनें:

private int getNavigationBarHeight() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        int usableHeight = metrics.heightPixels;
        getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
        int realHeight = metrics.heightPixels;
        if (realHeight > usableHeight)
            return realHeight - usableHeight;
        else
            return 0;
    }
    return 0;
}

तो डिवाइस की अंतिम ऊंचाई है:

int height = displayMetrics.heightPixels + getNavigationBarHeight();

Comments

यदि डिवाइस को घुमाया जाए तो क्या चौड़ाई और ऊँचाई की अदला-बदली होती है?

— 6ey में 6

@Madeyedexter हाँ, यह होगा।

— पराग चौहान

लेकिन आप अब यह नहीं मान सकते हैं कि आप डिफ़ॉल्ट डिस्प्ले पर चल रहे हैं।

— satur9nine

या बस बस का उपयोग करें - getResource ()। getDisplayMetrics ()। heightPixels / getources ()। getDisplayMetrics ()। widthPixels

— एलेक्स

@EpicPandaForce वास्तव में मैं एंड्रॉइड Oreo के बारे में सोच रहा था जो किसी अन्य डिस्प्ले पर गतिविधि शुरू करने की अनुमति देता है, निम्न देखें: डेवलपर.

— android.com/reference/android/app/…

Answer 2

बहुत ही सरल उत्तर है और बिना पास के संदर्भ है

public static int getScreenWidth() {
    return Resources.getSystem().getDisplayMetrics().widthPixels;
}

public static int getScreenHeight() {
    return Resources.getSystem().getDisplayMetrics().heightPixels;
}

नोट: यदि आप चाहते हैं कि ऊंचाई में नेविगेशन बार शामिल हो, तो नीचे विधि का उपयोग करें

WindowManager windowManager =
        (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
    final Display display = windowManager.getDefaultDisplay();
    Point outPoint = new Point();
    if (Build.VERSION.SDK_INT >= 19) {
        // include navigation bar
        display.getRealSize(outPoint);
    } else {
        // exclude navigation bar
        display.getSize(outPoint);
    }
    if (outPoint.y > outPoint.x) {
        mRealSizeHeight = outPoint.y;
        mRealSizeWidth = outPoint.x;
    } else {
        mRealSizeHeight = outPoint.x;
        mRealSizeWidth = outPoint.y;
    }

Comments

कुल स्क्रीन ऊंचाई कैसे प्राप्त करें? GetScreenHeight के इस संस्करण में सभी बार शामिल नहीं हैं।

— जयदेव

यह ज्यादातर मामलों में काम करता है, लेकिन अगर नेविगेशन बार दिखाई देता है तो यह वास्तविक स्क्रीन ऊंचाई नहीं पा सकता है। ऊंचाई बार की ऊंचाई को बाहर करती है।

— एल। स्विफ्टर

इसने मेरे लिए लैंडस्केप मोड में असामान्य परिणाम उत्पन्न किए

— कार्सन होल्जाइमर

यह कई डिस्प्ले (

— फोल्डेबल

नेविगेशन बार की ऊंचाई एंड्रॉइड 4.4

— मेस्टोइक

Answer 3

बस खंडित विधियों से वर्तमान एसडीके पिछड़े संगतता के साथ संरेखित करने के लिए पराग और एसकेके द्वारा उत्तर को अपडेट करने के लिए:

int Measuredwidth = 0;  
int Measuredheight = 0;  
Point size = new Point();
WindowManager w = getWindowManager();

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)    {
    w.getDefaultDisplay().getSize(size);
    Measuredwidth = size.x;
    Measuredheight = size.y; 
}else{
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
}

Comments

@digiphd Parang के कोड को सभी API संस्करणों पर काम नहीं करेगा? सभी तरीकों को एपीआई स्तर 8 से पहले पेश किया गया था और मुझे उन्हें एंड्रॉइड देव साइट पर नहीं मिला।

— सूफियान

@ सूफियान मुझे getSizeसैमसंग गैलेक्सी मिनी (एपीआई 10) पर कार्यान्वयन से गैर-0 रिटर्न मान प्राप्त करने में समस्या थी, लेकिन इस उत्तर में विधिवत तरीके सही तरीके से वापस आ गए। तो यह एंड्रॉइड के पुराने संस्करणों के लिए उपयोगी है।

— डेमियन डाइथल

@ सूफियान क्या हम स्क्रीन की चौड़ाई और ऊँचाई पर नए आयाम स्थापित कर सकते हैं?

— सृष्टि रॉय

यह अब मूल्यह्रास हो गया है :(

— सिगप्रकाश

Answer 4

क्यों नहीं

डिस्प्लेमेट्रिक्स डिस्प्लेमेट्रिक्स = getResources ()। GetDisplayMetrics ();

तो उपयोग करें

DisplayMetrics.widthPixels (heightPixels)

Answer 5

नीचे दिए गए कोड की कोशिश करें: -

1।

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

2।

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

या

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

3।

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

metrics.heightPixels;
metrics.widthPixels;

Comments

क्या आपको नहीं लगता 2 = 4

— त्रिकालदर्शी

मतलब आपकी विधि 2 विधि 4 के बराबर है

— त्रिकालदर्शी

क्या डिवाइस का "प्राकृतिक" रिज़ॉल्यूशन प्राप्त करना संभव है? इसका मतलब यह है कि अगर आप स्क्रीन को घुमाते हैं, तो आपको चौड़ाई और ऊंचाई के लिए समान मान मिलेंगे, और अगर यह एक टैबलेट है जिसका उपयोग क्षैतिज रूप से किया जाना है, तो यह चौड़ाई को ऊंचाई के बजाय बड़े के रूप में लौटाएगा?

— एंड्रॉइड डेवलपर

Answer 6

Android में प्राप्त करना बहुत आसान है:

int width  = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;

Comments

यह एक एमुलेटर पर 0 लौटाता है

— l3ob

Answer 7

कोटलिन उपयोगकर्ता के लिए

fun Activity.displayMetrics(): DisplayMetrics {
   val displayMetrics = DisplayMetrics()
   windowManager.defaultDisplay.getMetrics(displayMetrics)
   return displayMetrics
}

और गतिविधि में आप इसे पसंद कर सकते हैं

     resources.displayMetrics.let { displayMetrics ->
        val height = displayMetrics.heightPixels
        val width = displayMetrics.widthPixels
    }

या टुकड़े में

    activity?.displayMetrics()?.run {
        val height = heightPixels
        val width = widthPixels
    }

Answer 8

DisplayMetrics dimension = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dimension);
        int width = dimension.widthPixels;
        int height = dimension.heightPixels;

Answer 9

DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;

Answer 10

स्क्रीन की चौड़ाई और ऊँचाई का मान प्राप्त करें।

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

Answer 11

Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();

Comments

पदावनत, DisplayMetrics ()

— deyanm

Answer 12

public class DisplayInfo {
    int screen_height=0, screen_width=0;
    WindowManager wm;
    DisplayMetrics displaymetrics;

    DisplayInfo(Context context) {
        getdisplayheightWidth(context);
    }

    void getdisplayheightWidth(Context context) {
        wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        displaymetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displaymetrics);
        screen_height = displaymetrics.heightPixels;
        screen_width = displaymetrics.widthPixels;
    }

    public int getScreen_height() {
        return screen_height;
    }

    public int getScreen_width() {
        return screen_width;
    }
}

Answer 13

क्रोम ओएस मल्टीपल डिस्प्ले, या जल्द आने वाले फोल्डेबल्स के लिए यहां कोई भी उत्तर सही ढंग से काम नहीं करता है।

वर्तमान कॉन्फ़िगरेशन की तलाश करते समय, हमेशा अपनी वर्तमान गतिविधि से कॉन्फ़िगरेशन का उपयोग करें getResources().getConfiguration()। अपनी पृष्ठभूमि गतिविधि या सिस्टम संसाधन से एक से कॉन्फ़िगरेशन का उपयोग न करें। पृष्ठभूमि गतिविधि का आकार नहीं है, और सिस्टम के कॉन्फ़िगरेशन में परस्पर विरोधी आकार और झुकाव के साथ कई खिड़कियां हो सकती हैं , इसलिए कोई भी उपयोग करने योग्य डेटा नहीं निकाला जा सकता है।

तो जवाब है

val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp

Answer 14

यहाँ दिखाए गए तरीके अपवित्र / पुराने हैं लेकिन यह अभी भी काम कर रहा है। Rireire API 13

इसकी जांच - पड़ताल करें

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

Answer 15

इसे करने का पूरा तरीका, यही सच्चा संकल्प लौटाता है:

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

और चूंकि यह अलग-अलग अभिविन्यास पर बदल सकता है, यहां (कोटलिन में) एक समाधान है, इसे सही प्राप्त करने के लिए कोई उन्मुखीकरण नहीं है:

/**
 * returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
 * The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
    //based on : http://stackoverflow.com/a/9888357/878126
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val config = context.resources.configuration
    val rotation = windowManager.defaultDisplay.rotation
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
        Configuration.ORIENTATION_LANDSCAPE
    else
        Configuration.ORIENTATION_PORTRAIT
}

/**
 * returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
    val screenNaturalOrientation = getScreenNaturalOrientation(context)
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val point = Point()
    wm.defaultDisplay.getRealSize(point)
    val currentOrientation = context.resources.configuration.orientation
    if (currentOrientation == screenNaturalOrientation)
        return point
    else return Point(point.y, point.x)
}

Answer 16

नीचे दिए गए फ़ंक्शन का उपयोग करें जो पूर्णांक की एक सरणी के रूप में स्क्रीन आकार की चौड़ाई और ऊंचाई देता है

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

अपने ऑनक्रिएट फ़ंक्शन या बटन पर क्लिक करके निम्न कोड जोड़ें, जैसा कि नीचे दिखाया गया है

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);

Answer 17

कोटलिन के लिए इस कोड का प्रयास करें

 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y

Answer 18

स्क्रीन आयाम प्राप्त करने के लिए मैं निम्नलिखित कोड का उपयोग करता हूं

getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()

Answer 19

मैंने कोटलिन भाषा के लिए उत्तर अपडेट किया!

Kotlin के लिए: आपको विंडो मैनेजर को कॉल करना चाहिए और मैट्रिक्स प्राप्त करना चाहिए। उसके बाद आसान तरीका।

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

हम कोटलिन भाषा के साथ स्वतंत्र गतिविधि तरीके से इसे प्रभावी ढंग से कैसे उपयोग कर सकते हैं?

यहाँ, मैंने सामान्य कोटलिन वर्ग में एक विधि बनाई। आप इसे सभी गतिविधियों में उपयोग कर सकते हैं।

private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"

private fun getDeviceSizes(activity:Activity, whichSize:String):Int{

    val displayMetrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(displayMetrics)

    return when (whichSize){
        T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
        T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
        else -> 0 // Error
    }
}

संपर्क: @canerkaseler

Comments

हो सकता है कि एक्टिविटी क्लास के लिए एक एक्सटेंशन फ़ंक्शन बनाने के लिए भी बेहतर समाधान होगा।

— मीकर

Answer 20

मैंने पाया कि इस पृष्ठ में वेगन का उत्तर सबसे अच्छा है, यहाँ आप इसका उपयोग कैसे कर सकते हैं Xamarin.Android:

public int GetScreenWidth()
{
    return Resources.System.DisplayMetrics.WidthPixels;
}

public int GetScreenHeight()
{
    return Resources.System.DisplayMetrics.HeightPixels;
}

Answer 21

स्क्रीन रिज़ॉल्यूशन स्क्रीन में पिक्सेल की कुल संख्या नहीं है। निम्नलिखित कार्यक्रम डिवाइस के स्क्रीन रिज़ॉल्यूशन को निकाल देगा। यह स्क्रीन की चौड़ाई और ऊंचाई को प्रिंट करेगा। वे मान पिक्सेल में हैं।

public static Point getScreenResolution(Context context) {
// get window managers
WindowManager manager =  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Display display = manager.getDefaultDisplay();
Point point = new Point();
display.getSize(point);

 // get width and height
 int width = point.x;
 int height = point.y;

 return point;

}

Answer 22

एंड्रॉइड में साइज एब्स्ट्रैक्शन के साथ काम करने के लिए उपयोगिताओं का यह सेट ।

इसमें एक वर्ग SizeFromDisplay.java शामिल है आप इसे इस तरह से उपयोग कर सकते हैं:

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();

Answer 23

दो कदम। सबसे पहले, गतिविधि वर्ग का विस्तार करें

class Example extends Activity

दूसरा: इस कोड का उपयोग करें

 DisplayMetrics displayMetrics = new DisplayMetrics();
 WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
 windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
 int deviceWidth = displayMetrics.widthPixels;
 int deviceHeight = displayMetrics.heightPixels;

Answer 24

    int getScreenSize() {
        int screenSize = getResources().getConfiguration().screenLayout &
                Configuration.SCREENLAYOUT_SIZE_MASK;
//        String toastMsg = "Screen size is neither large, normal or small";
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        int orientation = display.getRotation();

        int i = 0;
        switch (screenSize) {

            case Configuration.SCREENLAYOUT_SIZE_NORMAL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_SMALL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_LARGE:
//                toastMsg = "Large screen";
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 2;
                } else {
                    i = 1;
                }


                break;
            case Configuration.SCREENLAYOUT_SIZE_XLARGE:
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 4;
                } else {
                    i = 3;
                }

                break;


        }
//        customeToast(toastMsg);
        return i;
    }

Answer 25

       @Override
        protected void onPostExecute(Drawable result) {
            Log.d("width",""+result.getIntrinsicWidth());
            urlDrawable.setBounds(0, 0, 0+result.getIntrinsicWidth(), 600);

            // change the reference of the current drawable to the result
            // from the HTTP call
            urlDrawable.drawable = result;

            // redraw the image by invalidating the container
            URLImageParser.this.container.invalidate();

            // For ICS
            URLImageParser.this.container.setHeight((400+URLImageParser.this.container.getHeight()
                    + result.getIntrinsicHeight()));

            // Pre ICS`enter code here`
            URLImageParser.this.container.setEllipsize(null);
        }

Comments

कृपया कोड के साथ कुछ स्पष्टीकरण लिखें। कोड केवल उत्तर आमतौर पर SO

— राम गद्याराम में