android रदर पिक्सल में स्क्रीन आयाम प्राप्त करें




होम स्क्रीन क्या है (24)

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

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

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


मेरे पास एक रैखिक स्क्रीन गतिविधि है जिसमें एक रैखिक लयआउट रूट रूट के रूप में है जिसमें इसकी चौड़ाई और ऊंचाई के लिए match_parent है । यह उस गतिविधि के onCreate() विधि में कोड है। मैं ऐप की सभी अन्य गतिविधियों में इन उपायों का उपयोग करता हूं।

int displayWidth = getRawDisplayWidthPreHoneycomb();
int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
pf.setScreenParameters(displayWidth, usableDisplayHeight);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
    myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
        @Override
        public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
            if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                return;
            }
            int displayWidth = Math.min(right, bottom);
            int usableDisplayHeight = Math.max(right, bottom);
            pf.setScreenParameters(displayWidth, usableDisplayHeight);
        }
    });
}

यहां दिए गए तरीकों के लिए कार्यान्वयन यहां दिए गए हैं:

private int getRawDisplayWidthPreHoneycomb() {
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int widthPixels = displayMetrics.widthPixels;
    int heightPixels = displayMetrics.heightPixels;

    return Math.min(widthPixels, heightPixels);
}

private int getRawDisplayHeightPreHoneycomb() {
    WindowManager w = getWindowManager();
    Display d = w.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    d.getMetrics(metrics);

    int widthPixels = metrics.widthPixels;
    int heightPixels = metrics.heightPixels;

    return Math.max(widthPixels, heightPixels);
}

public int getStatusBarHeight() {
    int statusBarHeight = 0;

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

    return statusBarHeight;
}

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


क्या यह एक बेहतर समाधान नहीं है? DisplayMetrics आपको आवश्यक सभी चीज़ों के साथ आता है और एपीआई 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+ पर काम करता है।

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


एक तरीका है:

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

इसे बहिष्कृत किया गया है, और आपको इसके बजाय निम्नलिखित कोड आज़माएं। कोड की पहली दो पंक्तियां आपको DisplayMetrics objecs देती हैं। इन ऑब्जेक्ट्स में ऊंचाई पिक्सेल, चौड़ाई पिक्सेल जैसे फ़ील्ड शामिल हैं।

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

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

(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 वाले हमारे अधिकांश उपयोगकर्ताओं पर भरोसा करते हैं, वहीं हम यही छोड़ते हैं।


पहले एक्सएमएल फ़ाइल लोड करें और फिर यह कोड लिखें:

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

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


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

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

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

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


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

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

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

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

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

मैंने असफल तरीके से सभी संभावित "समाधान" की कोशिश की है और मैंने देखा है कि इलियट ह्यूजेस 'डाल्विक एक्सप्लोरर "ऐप हमेशा किसी भी एंड्रॉइड डिवाइस / ओएस संस्करण पर सही आयाम दिखाता है। मैं अपनी ओपन सोर्स प्रोजेक्ट को देखकर समाप्त हुआ जो यहां पाया जा सकता है: 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) {
}

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

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

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

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

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


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

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


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

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;

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

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

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

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

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

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

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

22 अक्टूबर 2015

एक और तरीका है: DisplayMetrics

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

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

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

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

उदाहरण:

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

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

नीचे दिए गए उदाहरण, इस धागे पर सिनीक की प्रतिक्रिया से संशोधित, एक बटन दिखाता है जो स्क्रीन का 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>

स्क्रीन की चौड़ाई और ऊंचाई पाएं:

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

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;

सबसे आसान तरीका:

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

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

getResources().getDisplayMetrics().heightPixels;

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

getResources().getDisplayMetrics().widthPixels; 

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


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

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

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

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




dimensions