प्रोग्रामेटिक रूप से 7 इंच और 10 इंच टैबलेट का पता लगाएं


93

क्या प्रोग्राम को खोजने का एक तरीका है कि ऐप जिस डिवाइस पर इंस्टॉल किया गया है वह 7 इंच टैबलेट है या 10 इंच का टैबलेट?


उदाहरण के लिए: लेआउट- sw600dp 600dp की सबसे छोटी चौड़ाई के आकार के लिए दिखता है।
रूकी

मैं समझता हूं कि, लेकिन आप प्रोग्राम के लिए क्या देख रहे हैं?
भूतकाल

मुझे इन उपकरणों को प्रोग्रामिक रूप से लाने की आवश्यकता है..तो कुछ गुण हैं जिन्हें मैं xml में परिभाषित नहीं कर सकता हूं..तो गुण कोड में ही परिभाषित किए गए हैं .. इसलिए यदि मैं केवल कोड डालूं, तो यह सभी डिवाइसों पर लागू होगा..लेकिन मैं नहीं चाहता कि ..
रूकी

@ राघव ने स्क्रीन का आकार प्राप्त करने के लिए डिस्प्ले मैट्रिक्स के साथ प्रयास किया है और फिर आप तुलना कर सकते हैं। हालांकि इसका साफ तरीका नहीं है लेकिन आप इसका इस्तेमाल कर सकते हैं।
पीयूषमिश्रा

आप अपने स्क्रीन आयाम प्राप्त कर सकते हैं और वहां से काम कर सकते हैं ... stackoverflow.com/questions/1016896/…
Raj

जवाबों:


234

आप DisplayMetricsस्क्रीन के बारे में पूरी जानकारी प्राप्त करने के लिए उपयोग कर सकते हैं कि आपका ऐप किस पर चल रहा है।

सबसे पहले, हम एक DisplayMetricsमैट्रिक्स ऑब्जेक्ट बनाते हैं:

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

इससे हम डिस्प्ले को आकार देने के लिए आवश्यक जानकारी प्राप्त कर सकते हैं:

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

यह पिक्सेल में चौड़ाई और ऊंचाई का पूर्ण मान लौटाएगा, इसलिए गैलेक्सी SIII, गैलेक्सी नेक्सस आदि के लिए 1280x720।

यह आमतौर पर अपने आप में सहायक नहीं होता है, जब हम एंड्रॉइड डिवाइस पर काम कर रहे होते हैं, तो हम आमतौर पर घनत्व स्वतंत्र पिक्सल में काम करना पसंद करते हैं, डुबकी।

आप प्राप्त densityस्क्रीन का उपयोग करने का metricsडिवाइस है, जो पर आधारित है के लिए पैमाने कारक के रूप में फिर से, एंड्रॉयड डिजाइन संसाधन के लिए mdpi, hdpiआदि डीपीआई तराजू

float scaleFactor = metrics.density;

इस परिणाम से, हम एक निश्चित ऊंचाई या चौड़ाई के लिए घनत्व पिक्सेल की मात्रा की गणना कर सकते हैं।

float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor

इससे मिलने वाला परिणाम आपको यह तय करने में मदद करेगा कि आप एंड्रॉइड कॉन्फ़िगरेशन उदाहरणों के साथ किस प्रकार की स्क्रीन पर काम कर रहे हैं , जो आपको प्रत्येक स्क्रीन आकार के लिए सापेक्ष डीपी देता है:

  • 320dp: एक विशिष्ट फोन स्क्रीन (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, आदि)।
  • 480dp: स्ट्रीक (480x800 mdpi) जैसा एक ट्विन टैबलेट।
  • 600dp: एक 7 ”टैबलेट (600x1024 mdpi)।
  • 720dp: एक 10 ”टैबलेट (720x1280 mdpi, 800x1280 mdpi, आदि)।

उपरोक्त जानकारी का उपयोग करते हुए, हम जानते हैं कि यदि डिवाइस की सबसे छोटी-चौड़ाई 600dp से अधिक है, तो डिवाइस 7 "टैबलेट है, यदि यह 720dp से अधिक है, तो डिवाइस 10" टैबलेट है।

हम कक्षा की minकार्यप्रणाली का उपयोग करते हुए Math, heightDpऔर widthDpवापस लौटने के लिए छोटी चौड़ाई का काम कर सकते हैं smallestWidth

float smallestWidth = Math.min(widthDp, heightDp);

if (smallestWidth > 720) {
    //Device is a 10" tablet
} 
else if (smallestWidth > 600) {
    //Device is a 7" tablet
}

हालांकि, यह आपको हमेशा एक सटीक मैच नहीं देता है, खासकर जब अस्पष्ट गोलियों के साथ काम करना जो कि एचडीपीआई के रूप में उनके घनत्व को गलत तरीके से प्रस्तुत कर सकता है जब यह नहीं है, या यह केवल 800 x 480 पिक्सल हो सकता है, फिर भी एक 7 "स्क्रीन पर हो सकता है ।

इन विधियों के आगे, यदि आपको कभी किसी उपकरण के सटीक आयामों को इंच में जानने की आवश्यकता होती है, तो आप metricsस्क्रीन के प्रति इंच कितने पिक्सेल हैं, इस पद्धति का उपयोग करके आप इसे भी काम कर सकते हैं।

float widthDpi = metrics.xdpi;
float heightDpi = metrics.ydpi;

आप डिवाइस के प्रत्येक इंच में कितने पिक्सेल हैं और कुल कितने पिक्सेल डिवाइस काम करने के लिए कितने पिक्सल के ज्ञान का उपयोग कर सकते हैं।

float widthInches = widthPixels / widthDpi;
float heightInches = heightPixels / heightDpi;

यह इंच में डिवाइस की ऊंचाई और चौड़ाई वापस कर देगा। यह हमेशा यह निर्धारित करने के लिए सहायक नहीं होता है कि यह किस प्रकार का उपकरण है, क्योंकि किसी उपकरण का विज्ञापित आकार विकर्ण है, हमारे पास सभी की ऊंचाई और चौड़ाई है।

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

//a² + b² = c²

//The size of the diagonal in inches is equal to the square root of the height in inches squared plus the width in inches squared.
double diagonalInches = Math.sqrt(
    (widthInches * widthInches) 
    + (heightInches * heightInches));

इससे हम यह पता लगा सकते हैं कि उपकरण टैबलेट है या नहीं:

if (diagonalInches >= 10) {
    //Device is a 10" tablet
} 
else if (diagonalInches >= 7) {
    //Device is a 7" tablet
}

और इस तरह से आप गणना करते हैं कि आप किस प्रकार के उपकरण के साथ काम कर रहे हैं।


3
उत्कृष्ट सुझाव शॉन। मैं गोलियों के लिए पीएक्स के साथ जांच करता था, लेकिन कुछ मामलों में समस्याएं हैं (गैलेक्सी 3, 4, नोट, नेक्सस 7 की तुलना में बराबर या अधिक पीएक्स है)। अब मैं इंच की भी जांच कर सकता हूं। यहाँ कई लोकप्रिय उपकरणों की स्क्रीन स्पेक्स की सूची दी गई है: en.wikipedia.org/wiki/List_of_displays_by_pixel_density
पेलेन्स

8
Xdpi या ydpi का उपयोग न करें। ये वैकल्पिक हैं और निर्माता द्वारा निर्धारित किए जाएंगे, गणना नहीं। वे अक्सर अप्रयुक्त या गलत होते हैं।
sturrockad

2
डीपीआई में चौड़ाई प्राप्त करने के लिए अपने तरीके का उपयोग करके मुझे अभिविन्यास के आधार पर अलग-अलग परिणाम मिलते हैं। उदाहरण के लिए नेक्सस 7: पोर्ट्रेट: सबसे छोटा = 600.9; परिदृश्य: सबसे छोटा = 552.8; उसका क्या कारण है?
क्रिस्टोफर मैसर्स

3
तर्क if (smallestWidth > 600) { /* 7" */ } else if (smallestWidth > 720) { /* 10" */ }त्रुटिपूर्ण है: 10 "टैबलेट को 7 के रूप में पहचाना जाता है।" मैंने इसे ठीक करने के लिए स्वतंत्रता ली।
जोनीक

21
अंत में मैं के साथ चला गया resources.getConfiguration().smallestScreenWidthDpसे Deev का जवाब है जो केवल विधि है कि देता है दोनों पोर्ट्रेट और लैंडस्केप में समान मान मेरी नेक्सस 7 (600dp) पर। इसे एपीआई स्तर 13.
जोनिक में

32

ऐसा कुछ भी नहीं है जो कहे 7"या 10"AFAIK। लगभग दो तरीके हैं स्क्रीन आयाम प्राप्त करते हैं जो सिस्टम बिटमैप और व्हाट्सएप को डिकोड करते समय उपयोग करता है। वे दोनों आवेदन की Resourcesवस्तु में पाए जाते हैं Context

पहली Configurationवस्तु है जिसे प्राप्त किया जा सकता है getContext().getResources().getConfiguration()। इसमें आपके पास:

Configuration#densityDpi - लक्ष्य स्क्रीन घनत्व घनत्व संसाधन क्वालीफायर के अनुरूप प्रदान किया जा रहा है।

Configuration#screenHeightDp - उपलब्ध स्क्रीन स्पेस की वर्तमान ऊंचाई, डीपी इकाइयों में, स्क्रीन ऊंचाई संसाधन क्वालीफायर के अनुरूप है।

Configuration#screenWidthDp - dp इकाइयों में उपलब्ध स्क्रीन स्पेस की वर्तमान चौड़ाई, स्क्रीन चौड़ाई संसाधन क्वालीफायर के अनुरूप है।

Configuration#smallestScreenWidthDp - सबसे छोटी स्क्रीन का आकार एक एप्लिकेशन सामान्य ऑपरेशन में देखेगा, जो कि छोटी स्क्रीन चौड़ाई संसाधन क्वालीफायर के अनुरूप है।

कि के साथ, आप काफी स्क्रीन दिशानिर्देशों का उपयोग करता है, तो अपने डिवाइस (संबंधित विशेष संसाधन फ़ोल्डर से खींच रहा है यह पता लगाने की कर सकते हैं hdpi, xhdpi, large, xlarge, आदि)।

याद रखें, ये कुछ बाल्टी हैं:

  • xlarge स्क्रीन कम से कम 960dp x 720dp है
  • बड़ी स्क्रीन कम से कम 640dp x 480dp हैं
  • सामान्य स्क्रीन कम से कम 470dp x 320dp हैं
  • छोटे स्क्रीन कम से कम 426dp x 320dp हैं

  • 320dp: एक विशिष्ट फोन स्क्रीन (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, आदि)।

  • 480dp: स्ट्रीक (480x800 mdpi) जैसा एक ट्विन टैबलेट।
  • 600dp: एक 7 ”टैबलेट (600x1024 mdpi)।
  • 720dp: एक 10 ”टैबलेट (720x1280 mdpi, 800x1280 mdpi, आदि)।

और जानकारी

दूसरा DisplayMetricsप्राप्त वस्तु है getContext().getResources().getDisplayMetrics()। इसमें आपके पास है:

DisplayMetrics#density - प्रदर्शन का तार्किक घनत्व।

DisplayMetrics#densityDpi - स्क्रीन घनत्व डॉट्स-प्रति-इंच के रूप में व्यक्त किया गया।

DisplayMetrics#heightPixels - पिक्सल में डिस्प्ले की निरपेक्ष ऊंचाई।

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

DisplayMetrics#xdpi - एक्स आयाम में स्क्रीन के प्रति इंच सटीक भौतिक पिक्सेल।

DisplayMetrics#ydpi - वाई आयाम में स्क्रीन के प्रति इंच सटीक भौतिक पिक्सेल।

यह आसान है अगर आपको घनत्व के बजाय स्क्रीन की सटीक पिक्सेल गणना की आवश्यकता है। हालांकि, यह ध्यान रखना महत्वपूर्ण है कि यह स्क्रीन के सभी पिक्सेल हैं। सिर्फ आपके लिए उपलब्ध नहीं हैं।


4
+1, मुझे सबसे अच्छे परिणाम मिल रहे हैं smallestScreenWidthDp। अन्य समाधानों के विपरीत, यह अभिविन्यास की परवाह किए बिना मेरे Nexus 7 (600dp) पर समान मूल्य देता है । एक बोनस के रूप में, यह सबसे सरल कोड भी है!
जोनीक

1
मुझे लगता है कि यह सबसे अच्छा तरीका है क्योंकि यह संसाधन रास्तों पर sw ??? dp अंकन के साथ मेल खाना चाहिए । संगति जरूरी है।
लीलबर्डी

13

इस विधि को onResume () में रखें और चेक कर सकते हैं।

public double tabletSize() {

     double size = 0;
        try {

            // Compute screen size

            DisplayMetrics dm = context.getResources().getDisplayMetrics();

            float screenWidth  = dm.widthPixels / dm.xdpi;

            float screenHeight = dm.heightPixels / dm.ydpi;

            size = Math.sqrt(Math.pow(screenWidth, 2) +

                                 Math.pow(screenHeight, 2));

        } catch(Throwable t) {

        }

        return size;

    }

आम तौर पर गोलियाँ 6 इंच के आकार के बाद शुरू होती हैं।


8

पोर्ट्रेट बनाम परिदृश्य स्विच करते समय उपरोक्त हमेशा काम नहीं करता है।

यदि आप एपीआई स्तर 13+ को लक्षित कर रहे हैं, तो यह ऊपर वर्णित के रूप में आसान है - कॉन्फ़िगरेशन का उपयोग करें ।smallestScreenWidthDp, फिर तदनुसार परीक्षण करें:

resources.getConfiguration().smallestScreenWidthDp

अन्यथा, यदि आप इसे वहन कर सकते हैं, तो निम्नलिखित विधि का उपयोग करें जो कि 600dp (जैसे 6 ") बनाम 720dp (जैसे 10") का पता लगाने के लिए एक बहुत ही सटीक तरीका है, जो आपको बताएंगे:

1) लेआउट- sw600dp और लेआउट- sw720dp में जोड़ें (और यदि इसका परिदृश्य लागू होता है) उदाहरण के लिए उचित आईडी के साथ एक अदृश्य दृश्य:

720 के लिए, लेआउट- sw720dp पर:

<View android:id="@+id/sw720" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

600 के लिए, लेआउट- sw600dp पर:

<View android:id="@+id/sw600" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

2) फिर कोड पर, उदाहरण के लिए, गतिविधि, तदनुसार परीक्षण करें:

private void showFragment() {
    View v600 = (View) findViewById(R.id.sw600);
    View v720 = (View) findViewById(R.id.sw720);
    if (v600 != null || v720 !=null)
        albumFrag = AlbumGridViewFragment.newInstance(albumRefresh);
    else
        albumFrag = AlbumListViewFragment.newInstance(albumRefresh);
    getSupportFragmentManager()
        .beginTransaction()
        .replace(R.id.view_container, albumFrag)
        .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
        .commit();
}

4
आपको एक अलग लेआउट बनाने की आवश्यकता नहीं है, मेरा मानना ​​है कि आपके पास अलग-अलग मान हो सकते हैं। xml आकार के आधार पर, अलग-अलग मान फ़ोल्डर, जैसे मान-sw600dp, इत्यादि होने से एक स्ट्रिंग परिभाषित होता है <string name = 'screenize' > 600dp </ string> sw600dp फ़ोल्डर में, आदि। यह भी एक स्ट्रिंग होने की जरूरत नहीं है, यह ints.xml या dimens.xml में हो सकता है।
अंजनि Mar१

7

महान जानकारी, बस मैं क्या देख रहा था! हालाँकि, मैंने इसे आज़माने के बाद पाया कि जब नेक्सस 7 (2012 मॉडल) में उल्लिखित मेट्रिक्स का उपयोग करते हुए रिपोर्ट्स का आकार 1280x736 है। मेरे पास एक मोटोरोला ज़ूम है जो जेली बीन चल रहा है और यह गलत तरीके से 1280x752 के रिज़ॉल्यूशन की रिपोर्ट करता है। मैं इस पोस्ट पर ठोकर खाई यहाँ है कि यह पुष्टि करता है। मूल रूप से, आईसीएस / जेबी में उपर्युक्त मीट्रिक का उपयोग करते हुए गणना नेविगेशन बार के आयामों को बाहर करने के लिए दिखाई देती है। कुछ और शोधों ने मुझे फ्रैंक नुग्येन के उत्तर की ओर ले गए, जो विभिन्न तरीकों का उपयोग करते हैं जो आपको स्क्रीन के कच्चे (या वास्तविक) पिक्सेल आयाम देंगे। मेरे प्रारंभिक परीक्षण से पता चला है कि फ्रैंक कोरक्लेटी के निम्नलिखित कोड नेक्सस 7 (2012 मॉडल रनरिन जेबी) और मेरे मोटोरोला जूम पर चल रहे जेबी पर आयामों की रिपोर्ट करते हैं:

int width = 0, height = 0;
final DisplayMetrics metrics = new DisplayMetrics();
Display display = getWindowManager().getDefaultDisplay();
Method mGetRawH = null, mGetRawW = null;

try {
    // For JellyBeans and onward
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
        display.getRealMetrics(metrics);

        width = metrics.widthPixels;
        height = metrics.heightPixels;
    } else {
        mGetRawH = Display.class.getMethod("getRawHeight");
        mGetRawW = Display.class.getMethod("getRawWidth");

        try {
            width = (Integer) mGetRawW.invoke(display);
            height = (Integer) mGetRawH.invoke(display);
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
} catch (NoSuchMethodException e3) {
    e3.printStackTrace();
}

3

मेरे पास एक ही रिज़ॉल्यूशन वाले दो एंड्रॉइड डिवाइस हैं

डिवाइस 1 -> संकल्प 480x800 विकर्ण स्क्रीन आकार -> 4.7 इंच

डिवाइस 2 -> रिज़ॉल्यूशन 480x800 विकर्ण स्क्रीन आकार -> 4.0 इंच

यह दोनों डिवाइस को विकर्ण स्क्रीन आकार देता है -> 5.8

आपकी समस्या का हल है ।।

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width=dm.widthPixels;
int height=dm.heightPixels;
int dens=dm.densityDpi;
double wi=(double)width/(double)dens;
double hi=(double)height/(double)dens;
double x = Math.pow(wi,2);
double y = Math.pow(hi,2);
double screenInches = Math.sqrt(x+y);

यहाँ देखें विवरण ..


2

वे कहते हैं कि एंड्रॉइड स्क्रीन का आकार चार सामान्यीकृत आकारों के माध्यम से होता है: छोटे , सामान्य , बड़े और ज़ेलेगे

जबकि एंड्रॉइड डॉक्यूमेंटेशन बताता है कि आकार समूहों को हटा दिया गया है

... इन आकार समूहों को स्क्रीन आकार उपलब्ध स्क्रीन चौड़ाई के आधार पर प्रबंधित करने के लिए एक नई तकनीक के पक्ष में चित्रित किया गया है। यदि आप एंड्रॉइड 3.2 और अधिक के लिए विकसित कर रहे हैं, तो अधिक जानकारी के लिए देखें [घोषणा Android के लिए टैबलेट लेआउट] (एचडीपीआई (उच्च) ~ 240dpi)।

आम तौर पर आकार क्वालीफायर बड़ा 7 "टैबलेट निर्दिष्ट करता है। और xlarge का आकार क्वालीफायर 10" टैबलेट निर्दिष्ट करता है:

यहां छवि विवरण दर्ज करें

आकार क्वालीफायर पर ट्रिगर करने के बारे में अच्छी बात यह है कि आप यह गारंटी दे सकते हैं कि आपकी संपत्ति और कोड समझौते में हैं, जिस पर संपत्ति का उपयोग करना है या सक्रिय करने के लिए कोड पथ।

कोड में आकार क्वालिफायर प्राप्त करने के लिए निम्नलिखित कॉल करें:

int sizeLarge = SCREENLAYOUT_SIZE_LARGE // For 7" tablet
boolean is7InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeLarge);

int sizeXLarge = SCREENLAYOUT_SIZE_XLARGE // For 10" tablet
boolean is10InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeXLarge);

2

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

private static double checkDimension(Context context) {

    WindowManager windowManager = ((Activity)context).getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    // since SDK_INT = 1;
    int mWidthPixels = displayMetrics.widthPixels;
    int mHeightPixels = displayMetrics.heightPixels;

    // includes window decorations (statusbar bar/menu bar)
    try
    {
        Point realSize = new Point();
        Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize);
        mWidthPixels = realSize.x;
        mHeightPixels = realSize.y;
    }
    catch (Exception ignored) {}

    DisplayMetrics dm = new DisplayMetrics();
    windowManager.getDefaultDisplay().getMetrics(dm);
    double x = Math.pow(mWidthPixels/dm.xdpi,2);
    double y = Math.pow(mHeightPixels/dm.ydpi,2);
    double screenInches = Math.sqrt(x+y);
    Log.d("debug","Screen inches : " + screenInches);
    return screenInches;
}

2

मैं मान फ़ोल्डर में एक मान संग्रहीत कर रहा था जो मुझे स्क्रीन 7 इंच या 10 इंक देता है, लेकिन हम इसे किसी भी डिवाइस के लिए मान फ़ोल्डर का उपयोग करके कर सकते हैं।

जैसे विभिन्न -2 उपकरणों के लिए अलग -2 मान फ़ोल्डर बनाएँ। लेकिन यह बात आवश्यकता पर निर्भर करती है।


1

आपको DisplayMetrics वर्ग द्वारा दिए गए डेटा का उपयोग करके थोड़ी गणना करनी होगी ।

आपके पास heightPixel और widthPixels (पिक्सेल में स्क्रीन रिज़ॉल्यूशन)

आपको विकर्ण की आवश्यकता है क्योंकि 'इंच स्क्रीन आकार' हमेशा विकर्ण लंबाई का वर्णन करता है। आप पिक्सेल में स्क्रीन विकर्ण प्राप्त कर सकते हैं (पाइथागोर का उपयोग करके)

विकर्णपक्षी = √ (ऊँचाईपिक्सल width + चौड़ाईपिक्सलel)

उसके बाद आप घनत्व मान के लिए पिक्सेल मान को इंच में बदल सकते हैं:

inchDiag = विकर्ण पिक्सिल / घनत्वडीपीआई।

मुझे आशा है कि मैंने यहाँ गलतियाँ नहीं की हैं, इस बात से अवगत रहें कि DisplayMetrics क्लास से आपको जो वैल्यूज़ मिलती हैं, वह कंस्ट्रक्टर द्वारा दी जाती हैं, ऐसा प्रतीत होता है (बहुत दुर्लभ मामलों में) कि वे भौतिक सामग्री के अनुसार अच्छी तरह से सेट नहीं हैं ...

यह आपको भौतिक स्क्रीन का आकार देगा लेकिन इसका संभवत: कई लेआउट को प्रबंधित करने का बेहतर तरीका नहीं है। इस विषय पर अधिक


1

दूसरा रास्ता:

  • 2 और फ़ोल्डर बनाएँ: मान-बड़े + मान- xlarge

  • रखो: <string name="screentype">LARGE</string>मूल्यों में बड़े फ़ोल्डर (strings.xml)

  • रखो: <string name="screentype">XLARGE</string>मूल्यों में- xlarge फ़ोल्डर (strings.xml)

  • कोड में:

    स्ट्रिंग mType = getString (R.string.screentype);

    अगर (mType! = null && mType.equals ("LARGE") {

    // 4 ~ 7 इंच से

    } और अगर (mType! = null && mType.equals ("XLARGE") {

    // 7 ~ 10 इंच से

    }


1

देखा! You यह सब आप फोन से गोलियाँ भेद करने की आवश्यकता होगी

1. स्क्रीन की चौड़ाई प्राप्त करने के लिए हेल्पर फ़ंक्शन:

private float getScreenWidth() {
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}

2. यह पता लगाने के लिए कि क्या कोई डिवाइस एक टैबलेट है

boolean isTablet() {
    return getScreenWidth() >= 600;
}

3. अंत में, यदि आप विभिन्न डिवाइस आकार के लिए अलग-अलग ऑपरेशन करना चाहते हैं:

boolean is7InchTablet() {
    return getScreenWidth() >= 600 && getScreenWidth() < 720;
}

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}

0

यहाँ कुछ उपयोगी कोटलिन एक्सटेंशन हैं:


    fun DisplayMetrics.isTablet(): Boolean {
        return screenWith() >= 600
    }

    fun DisplayMetrics.is7InchTablet(): Boolean {
        return screenWith() >= 600 && screenWith() < 720
    }

    fun DisplayMetrics.is10InchTablet(): Boolean {
        return screenWith() >= 720
    }

    fun DisplayMetrics.screenWith(): Float {
        return widthPixels.coerceAtMost(heightPixels) / density
    }

यह काम करता है! लेकिन आप से उचित DisplayMetrics, उदाहरण के लिए उपयोग करना चाहिए Resourcesमें Context: resources.displayMetrics.isTablet() या से WindowManagerजो में संग्रहीत Activity: val displayMetrics = DisplayMetrics() windowManager.defaultDisplay.getMetrics(displayMetrics) displayMetrics.isTablet()
Akbolat एसएसएस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.