android - रदर - होम स्क्रीन क्या है




पिक्सल में स्क्रीन आयाम प्राप्त करें (20)

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

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

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

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


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

नमूना कोड

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

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

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

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


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

getResources().getDisplayMetrics().heightPixels;

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

getResources().getDisplayMetrics().widthPixels; 

एक तरीका है:

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;

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

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

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

प्रथम:

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

दूसरा:

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

इन सभी विधियों को हम यहां कॉल नहीं करते हैं।


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

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

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

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

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

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


मेरे पास एक रैखिक स्क्रीन गतिविधि है जिसमें एक रैखिक लयआउट रूट रूट के रूप में है जिसमें इसकी चौड़ाई और ऊंचाई के लिए 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;
}

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


मैं इस तरह 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;
}

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

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

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

<?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() स्क्रीन की ऊंचाई वापस कर देगा।


यदि आप पिक्सेल में डिस्प्ले आयाम चाहते हैं तो आप 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);

यह ओपी के लिए उत्तर नहीं है, क्योंकि वह वास्तविक पिक्सेल में डिस्प्ले आयाम चाहता था। मैं "डिवाइस-स्वतंत्र-पिक्सल" में आयाम चाहता था, और यहां से https://.com/a/17880012/253938 से जवाब एकत्र कर रहा हूं और यहां https://.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);

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

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

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


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


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

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;

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

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

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




dimensions