टेबलेट या फ़ोन - Android

140

क्या यह जांचने का कोई तरीका है कि क्या उपयोगकर्ता टैबलेट या फोन का उपयोग कर रहा है? मुझे अपने झुकाव समारोह और मेरे नए टैबलेट (ट्रांसफार्मर) के साथ समस्याएं हैं

android  tablet 
— बेनी
स्रोत
26
आप गलत सवाल पूछ रहे हैं। इससे कोई फर्क नहीं पड़ता कि डिवाइस एक फोन, टैबलेट, टेलीविजन, टोस्टर, टेची, या थर्मामीटर है। क्या मायने रखती हैं, उपकरण की मार्केटिंग-परिभाषित वर्ग नहीं। कृपया एक ताज़ा एंड्रॉइड प्रश्न पूछें, जिसमें बताया गया है कि आप कौन सी क्षमताओं की तलाश कर रहे हैं और यह कैसे पता लगा सकते हैं कि डिवाइस में ऐसी क्षमताएं हैं या ऐसी क्षमताओं की कमी वाले उपकरणों के लिए बाज़ार से खुद को कैसे फ़िल्टर करें।
— कॉमन्सवेअर
7
@CommonsWare: कुछ समय के लिए आप उन उपकरणों के लिए अतिरिक्त सुविधाएँ जोड़ना चाहते हैं जिनमें स्क्रीन बड़ी है।
— बोब्स
10
@breceivemail: जिसका अर्थ है कि आपको यह जांचने की आवश्यकता है कि डिवाइस में बड़ी स्क्रीन है या नहीं। "बड़ी स्क्रीन"! = "टैबलेट"।
— कॉमन्सवेयर
2
एक बेहतर उत्तर यहां पाया जा सकता है: stackoverflow.com/a/9308284/1750829 उस के रूप में सरल :-)
— या कज़ाज़
3
मैं इस पूरे पेज को डाउनवोट करना चाहूंगा! एक फोन टेलीफोनी करता है, एक टैबलेट नहीं। बहुत सारे सुझाव गंदे हैक हैं जिनका किसी को उपयोग नहीं करना चाहिए। दुनिया एक बेहतर जगह होगी अगर किसी ने इस पृष्ठ को फिर कभी नहीं देखा!
— मार्क Gjøl

जवाबों:

122

जैसा कि पहले उल्लेख किया गया है, आप यह जांचना नहीं चाहते हैं कि डिवाइस टैबलेट है या फोन, लेकिन आप डिवाइस की विशेषताओं के बारे में जानना चाहते हैं,

अधिकांश समय, टैबलेट और फोन के बीच का अंतर स्क्रीन का आकार होता है, यही वजह है कि आप विभिन्न लेआउट फ़ाइलों का उपयोग करना चाहते हैं। इन फ़ाइलों को res/layout-<qualifiers>निर्देशिकाओं में संग्रहीत किया जाता है । आप res/values-<same qualifiers>अपने प्रत्येक लेआउट के लिए निर्देशन में एक XML फ़ाइल बना सकते हैं और अपने द्वारा उपयोग किए जाने वाले लेआउट के बीच अंतर करने के लिए इसमें एक int / bool / string संसाधन डाल सकते हैं।

उदाहरण:

फ़ाइल res/values/screen.xml(मानती है कि res/layout/हैंडसेट के लिए आपकी लेआउट फ़ाइलें हैं)

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">phone</string>
</resources>


फ़ाइल res/values-sw600dp/screen.xml(यह मानते हुए res/layout-sw600dp/कि Nexus 7 जैसी छोटी गोलियों के लिए आपकी लेआउट फ़ाइलें हैं)

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">7-inch-tablet</string>
</resources>


फ़ाइल res/values-sw720dp/screen.xml(संभालने res/layout-sw720dp/में नेक्सस 10 जैसी बड़ी गोलियों के लिए आपकी लेआउट फाइलें शामिल हैं):

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">10-inch-tablet</string>
</resources>


अब स्क्रीन प्रकार R.string.screen_typeनिरंतर के माध्यम से सुलभ है।

— जॉन
स्रोत
4
+1, महान जवाब, क्योंकि यह में और अधिक जानकारी प्रदान करता है क्यों कि आप वास्तव में गोली / फोन के लिए जाँच करना चाहते हैं। हम एक पल के लिए आ रहे हैं जिसमें फोन छोटी गोलियाँ बन जाएंगे;)
— andr
यह बड़े फोन पर कैसे लागू होता है, जैसे कि गैलेक्सी नोट और नया नेक्सस 6? इस तकनीक का उपयोग करके, क्या इन बड़े उपकरणों को फोन या टैबलेट के रूप में पहचाना जाएगा?
— PerracoLabs
1
दुर्भाग्य से, यह ऐपॉर्च सैमसंग मेगा 6.3 डिवाइस के लिए काम नहीं करता है और इसे टैबलेट (sw600dp) के रूप में लौटाता है - इस पर कब्जा करने के लिए कोई अन्य विचार?
— bkurzius
क्या गोलियाँ फ़ोन कॉल करती हैं?
— माइक
61

यह पता लगाने के लिए कि उपकरण टेबलेट है या नहीं, निम्नलिखित कोड का उपयोग करें:

public boolean isTablet(Context context) {
    boolean xlarge = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE);
    boolean large = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE);
    return (xlarge || large);
}

LARGE और XLARGE स्क्रीन साइज़ निर्माता द्वारा निर्धारित की जाती है, जिसका उपयोग उस आँख से दूरी के आधार पर किया जाता है जिस पर उनका उपयोग किया जाता है (इस प्रकार टैबलेट का विचार)।

अधिक जानकारी: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

— पीटी
स्रोत
दोनों पर - किंडल फायर और मोटोरोला ड्रॉयड बायोनिक - SCREENLAYOUT_SIZE_MASK == 15. तो आपका समाधान क्यों काम करेगा?
— इगोरगानपोलस्की
मेरा मानना ​​है, किंडल फायर पर यह सच है। मेरे पास आज मेरे पास बायोनिक नहीं है ... लेकिन मैं कुछ दिनों में जांच करूंगा कि मेरा दोस्त कब शहर में आएगा। हालाँकि ..... मैं हेल्टन इसाक के उत्तर का परीक्षण कर रहा हूँ और यह खूबसूरती से काम करता है। कृपया इसे भी देखें।
— पेटी
4
ऐसा है Configuration.SCREENLAYOUT_SIZE_XLARGE, इसलिए आपको एक स्थिरांक का उपयोग करने की आवश्यकता नहीं है, और आप इसका उपयोग कर सकते हैं >= LARGE।
— त्रिकोणीय 3
2
गैलेक्सी नोट SCREENLAYOUT_SIZE_LARGE की रिपोर्ट करता है, इसलिए इसे गलत तरीके से टैबलेट के रूप में वर्गीकृत किया जाएगा
— MiguelSantirso
1
यदि डिवाइस का फ़ॉन्ट छोटा है और डिस्प्ले का आकार सेटिंग्स में छोटा है, तो यह मामला सही है।
— arul
38

इस पोस्ट ने मुझे बहुत मदद की,

दुर्भाग्य से मेरे पास उन सभी उत्तरों का मूल्यांकन करने के लिए आवश्यक प्रतिष्ठा नहीं है, जिन्होंने मेरी मदद की।

मुझे यह पहचानने की आवश्यकता थी कि क्या मेरा उपकरण टैबलेट या फोन है, इसके साथ मैं स्क्रीन के तर्क को लागू करने में सक्षम होऊंगा। और मेरे विश्लेषण में टैबलेट एमडीपीआई पर शुरू होने वाले 7 इंच (एक्सलरेज) से अधिक होना चाहिए।

यहाँ नीचे कोड है, जो इस पोस्ट के आधार पर बनाया गया था।

/**
 * Checks if the device is a tablet or a phone
 * 
 * @param activityContext
 *            The Activity Context.
 * @return Returns true if the device is a Tablet
 */
public static boolean isTabletDevice(Context activityContext) {
    // Verifies if the Generalized Size of the device is XLARGE to be
    // considered a Tablet
    boolean xlarge = ((activityContext.getResources().getConfiguration().screenLayout & 
                        Configuration.SCREENLAYOUT_SIZE_MASK) == 
                        Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI
    // (160dpi)
    if (xlarge) {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity) activityContext;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160,
        // DENSITY_TV=213, DENSITY_XHIGH=320
        if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT
                || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH
                || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM
                || metrics.densityDpi == DisplayMetrics.DENSITY_TV
                || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) {

            // Yes, this is a tablet!
            return true;
        }
    }

    // No, this is not a tablet!
    return false;
}
— हेल्टन इसाक
स्रोत
2
सबसे अच्छा समाधान जो मुझे मिला, धन्यवाद हेलन इसाक! शायद आप स्क्रीन के इंच के लिए एक बेहतर समाधान (एक बेहतर समाधान के लिए) जोड़ सकते हैं? वैसे भी, इस समाधान के लिए एक 10
— Aracem
7
मैं वास्तव में असहमत हूं । यह एक निश्चित स्क्रीन आकार खोजने की एक विधि है। फिर से, जैसा कि मैंने उत्तर दिया है, टैबलेट और फोन के बीच कोई अंतर नहीं है। यह सवाल का जवाब नहीं है। 1 अंतर नहीं होने के कारण अंतर करना संभव नहीं है। यदि आपको कुछ विशेषताओं के लिए कोड करने की आवश्यकता है (जैसे आप कुछ स्क्रीन आकारों के लिए करते हैं), तो ऐसा करें, लेकिन इसे टैबलेट बनाम फोन न कहें। टॉपिक स्टार्टर लाइन @ निश्चित झुकाव कार्यक्षमता डाल रहा था। इस सवाल पर @commonware की टिप्पणी को thourougly पढ़ें।
— नन्ने
1
मैं नन्ने से सहमत हूं, लेकिन जैसा कि मैंने कहा, मेरे आवेदन में मुझे दो पैनल दिखाने की जरूरत है अगर स्क्रीन ऐसा करने के लिए पर्याप्त बड़ी है। और मैं इस मामले में लेआउट का उपयोग नहीं कर सकता, क्योंकि स्क्रीन तर्क जावा पक्ष में था।
— हेल्टन इसाक
3
हेल्टन, इसके लिए thx। मैंने सोचा था कि यह रिटर्न: जलाने की आग: झूठी, मोटो Xoom (v1): सच, गैलेक्सी नोट: गलत, गैलेक्सी टैब 10.1 सीमित: सच
— पेटी
तर्क के अलावा, configuration.SCREENLAYOUT_SIZE_XLARGE = 4 डेवलपर.
— android.com/reference/android/content/res/… के
12

स्क्रीन विकर्ण के आकार की गणना क्यों न करें और इसका उपयोग यह निर्णय लेने के लिए करें कि क्या डिवाइस फोन या टैबलेट है?

private boolean isTablet()
{
    Display display = getWindowManager().getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

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

    double screenDiagonal = Math.sqrt( width * width + height * height );
    return (screenDiagonal >= 9.0 );
}

बेशक कोई यह तर्क दे सकता है कि क्या सीमा 9 इंच या उससे कम होनी चाहिए।

— वोल्कर वीकिंग
स्रोत
यह काम नहीं कर रहा है ... बस कुछ फोन गलत घनत्व मूल्यों की रिपोर्ट करते हैं और इंच में गणना विफल हो जाती है - वहां देखें: stackoverflow.com/questions/2193457/…
— STeN
खैर, मुझे 7 'टैबलेट (पॉकेट साइज) पसंद हैं और यह जवाब मेरे हिसाब से सबसे अच्छा है। लेकिन वापसी (स्क्रीनडायंगल> = 9.0); लौटना चाहिए (स्क्रीनडायंगल> = 6.5)। हालांकि इस सवाल पर टिप्पणी में टिप्पणी के रूप में उपयोग पर निर्भर है।
— Jan Bergström
11

इसमें कोई फर्क नही है। आपको परिभाषित करना चाहिए कि आपको क्या लगता है कि अंतर क्या है, और इसके लिए जांच करें। क्या आकाशगंगा टैब एक फोन है? या एक गोली? और क्यों?

आपको यह परिभाषित करना चाहिए कि आप किन विशिष्ट विशेषताओं की तलाश कर रहे हैं, और उसके लिए कोड।

लगता है आप for झुकाव ’की तलाश में हैं। मुझे लगता है कि यह एक्सेलेरोमीटर (यह एक शब्द है?) के समान है। यदि डिवाइस इसका समर्थन करता है, तो आप केवल जाँच कर सकते हैं:

public class Accel extends Activity implements SensorListener {
...
  SensorManager sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);
  boolean accelSupported = sensorMgr.registerListener(this,
        SENSOR_ACCELEROMETER,
        SENSOR_DELAY_UI);
...
}

( http://stuffthathappens.com/blog/2009/03/03/15/android-accelerometer/ से । मैंने इसका परीक्षण नहीं किया है)।

— Nanne
स्रोत
मुझे अपने झुकाव समारोह और मेरे नए टैबलेट (ट्रांसफार्मर) के साथ समस्याएं हैं
— बेनी
एक मूर्खतापूर्ण उत्तर imo की तरह - बेशक वहाँ एक अंतर है। गैलेक्सी = फोन। क्यों? क्योंकि यह एक के लिए निर्माता के अनुसार एक "स्मार्टफोन" है। यदि आप संकेत दे रहे हैं कि उसे आकार, या कॉल करने की क्षमता, या ... कुछ भी - की जांच करने की आवश्यकता है, तो बस यही कहें।
— डेव
3
मैं असहमत हूं, यह सभी मोबाइलों के लिए काम नहीं कर सकता है, जबकि कुछ टैबलेट में ये सेंसर हैं। इसीलिए बिना किसी अंतर के बारे में मेरा शुरुआती जवाब। वैसे भी, मैंने कुछ कोड जोड़े हैं जिन्हें आपको आज़माना चाहिए।
— नन्ने
2
समस्या यह है कि, क्योंकि लैंडस्केप मोड में टैबलेट "बिल्ड" होते हैं और एक्सेलेरोमीटर के x और y अक्ष को फ़्लिप किया जाता है जब आप अपने ऐप को पोर्ट्रेट मोड में चलने की उम्मीद करते हैं। यह चीजों को थोड़ा गड़बड़ कर सकता है :) इसलिए यह महत्वपूर्ण है कि आप मौसम की जांच करें कि आप टैबलेट पर चल रहे हैं या नहीं।
— कद्दू
1
लेकिन फिर यह चारों ओर का दूसरा तरीका है => अगर केवल वही चीज है जो डिवाइस को टैबलेट बनाती है, तो आपको यह पता लगाना चाहिए कि x / y अक्ष कैसे काम करता है, अन्य तरीके से नहीं। मैं इस तरह से संदेह करता हूं कि यह सभी टैबलेट और / या फोन के लिए सच है?
— नन्हें
10

मेरी धारणा यह है कि जब आप 'मोबाइल / फोन' को परिभाषित करते हैं, तो आप यह जानना चाहते हैं कि क्या आप उस डिवाइस पर एक फोन कॉल कर सकते हैं जो किसी ऐसी चीज पर नहीं किया जा सकता है जिसे 'टैबलेट' के रूप में परिभाषित किया जाएगा। इसे सत्यापित करने का तरीका नीचे है। यदि आप सेंसर, स्क्रीन के आकार आदि के आधार पर कुछ जानना चाहते हैं तो यह वास्तव में एक अलग सवाल है।

इसके अलावा, स्क्रीन रिज़ॉल्यूशन का उपयोग करते समय, या संसाधन प्रबंधन बड़े बनाम एक्सलर्ज, पिछले नए 'मोबाइल' उपकरणों में एक वैध दृष्टिकोण हो सकता है, अब ऐसे बड़े स्क्रीन और उच्च संकल्प के साथ आ रहे हैं कि वे इस लाइन को धुंधला कर रहे हैं जब आप वास्तव में चाहते हैं फोन कॉल पता करने के लिए बनाम फोन कॉल की क्षमता नीचे 'सर्वश्रेष्ठ' है।

TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){
    return "Tablet";
}else{
    return "Mobile";
}
— रॉबर्ट डेल जॉनसन III
स्रोत
9
कुछ टैबलेट फोन कर सकते हैं और उनमें एक जीएसएम या सीडीएमए प्रकार है ... इसलिए आपका समाधान भी सही नहीं है।
— arnouf
6

रॉबर्ट डेल जॉनसन III और हेल्टन इसाक के आधार पर मैं इस कोड के साथ आया था आशा है कि यह उपयोगी है 

public static boolean isTablet(Context context) {
    TelephonyManager manager = 
        (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
    if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) {
        //Tablet
        return true;
    } else {
        //Mobile
        return false; 
    }
}

public static boolean isTabletDevice(Context activityContext) {
    // Verifies if the Generalized Size of the device is XLARGE to be
    // considered a Tablet
    boolean xlarge = 
         ((activityContext.getResources().getConfiguration().screenLayout & 
           Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI (160dpi)
    if (xlarge) {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity) activityContext;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160,
        // DENSITY_TV=213, DENSITY_XHIGH=320
        if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT
                  || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH
                  || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM   
                  || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) {

             // Yes, this is a tablet!
             return true;
        }
    }

    // No, this is not a tablet!
    return false;
}

तो अपने कोड में जैसे एक फिल्टर बनाते हैं

if(isTabletDevice(Utilities.this) && isTablet(Utilities.this)){
    //Tablet
} else {
    //Phone
}
— Cjames
स्रोत
6

Google IOSched 2017 एप्लिकेशन स्रोत कोड में , निम्न विधि का उपयोग किया जाता है:

public static boolean isTablet(Context context) {
    return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
}
— मूरत
स्रोत
3

उन लोगों के लिए जो Google को यह निर्धारित करने के लिए कोड का उपयोग करना चाहते हैं कि कौन से उपकरण टेबलेट यूआई का उपयोग करेंगे:

  // SystemUI (status bar) layout policy
        int shortSizeDp = shortSize
                * DisplayMetrics.DENSITY_DEFAULT
                / DisplayMetrics.DENSITY_DEVICE;

        if (shortSizeDp < 600) {
            // 0-599dp: "phone" UI with a separate status & navigation bar
            mHasSystemNavBar = false;
            mNavigationBarCanMove = true;
        } else if (shortSizeDp < 720) {
            // 600-719dp: "phone" UI with modifications for larger screens
            mHasSystemNavBar = false;
            mNavigationBarCanMove = false;
        } else {
            // 720dp: "tablet" UI with a single combined status & navigation bar
            mHasSystemNavBar = true;
            mNavigationBarCanMove = false;
        }
        }
— पियर बेटोस
स्रोत
2
का मूल्य क्या है shortSize?
— kc ochibili
3

यह विधि Google द्वारा सुझाई गई है। मैं इस कोड को Google Offical Android App में देखता हूंiosched

public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}
— hqt
स्रोत
यह समाधान उदाहरण के लिए एपीआई 18 और नेक्सस 7 1200 x 1920 xhdpi के साथ एक एमुलेटर पर काम नहीं कर रहा है!
— इंगू
1
आपको वास्तविक डिवाइस पर परीक्षण करना चाहिए :)
— hqt
मैं एम्युलेटर पर परीक्षण किया है और "isTablet (संदर्भ संदर्भ) का परिणाम झूठा था एम्युलेटर पर स्वयं के द्वारा की कोशिश
— इंगो
1
इस @hqt के लिए धन्यवाद, मैंने इसे Xamarin स्टूडियो के लिए C # की जरूरत के लिए ट्रांसकोड किया है:public static bool isTablet (Context context) { return (context.Resources.Configuration.ScreenLayout & Android.Content.Res.ScreenLayout.SizeMask) >= Android.Content.Res.ScreenLayout.SizeLarge; }
— फिल रयान
2

कोई कोड की जरूरत है

अन्य उत्तर प्रोग्राम को निर्धारित करने के कई तरीकों को सूचीबद्ध करते हैं कि क्या डिवाइस फोन या टैबलेट है। हालाँकि, यदि आप दस्तावेज़ीकरण पढ़ते हैं, तो यह विभिन्न स्क्रीन आकारों का समर्थन करने के लिए अनुशंसित तरीका नहीं है।

इसके बजाय, टैबलेट या फोन के लिए विभिन्न संसाधनों की घोषणा करें। आप के लिए इसे मेरा जोड़ने अतिरिक्त संसाधन फ़ोल्डर करते हैं layout, valuesआदि

  • एंड्रॉइड 3.2 (एपीआई स्तर 13) के लिए, एक sw600dpफ़ोल्डर जोड़ें । यह साधन है mallest डब्ल्यू idth जो लगभग फ़ोन / टेबलेट विभाजित है कम से कम 600dp है। हालाँकि, आप अन्य आकारों को भी जोड़ सकते हैं। अतिरिक्त लेआउट संसाधन फ़ाइल को जोड़ने के तरीके के लिए इस उत्तर की जाँच करें ।

  • यदि आप प्री एंड्रॉइड 3.2 डिवाइस का भी समर्थन कर रहे हैं, तो आपको टैबलेट का समर्थन करने के लिए फ़ोल्डर largeया xlargeफ़ोल्डर जोड़ना होगा । (फ़ोन आम तौर पर smallऔर हैं normal)

यहां विभिन्न स्क्रीन आकारों के लिए एक अतिरिक्त xml फ़ाइलों को जोड़ने के बाद आपके संसाधन क्या पसंद कर सकते हैं, इसकी एक छवि है।

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

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

टिप्पणियाँ

  • समान संसाधन फ़ाइलों को डुप्लिकेट करने से बचने के लिए आप उपनाम का उपयोग कर सकते हैं ।

Android डॉक्स पढ़ने लायक

— Suragch
स्रोत
2

यदि आप केवल एपीआई स्तर> = 13 को लक्षित कर रहे हैं तो प्रयास करें

public static boolean isTablet(Context context) {
    return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
}

चीयर्स :-)

— मोहनराज बालसुब्रमण्यम
स्रोत
1

"नई" अभिज्ञात निर्देशिकाओं (उदाहरण के लिए मान-sw600dp) पर विचार करके मैंने स्क्रीन / चौड़ाई के आधार पर यह विधि बनाई:

 public static final int TABLET_MIN_DP_WEIGHT = 450;
 protected static boolean isSmartphoneOrTablet(Activity act){
    DisplayMetrics metrics = new DisplayMetrics();
    act.getWindowManager().getDefaultDisplay().getMetrics(metrics);

    int dpi = 0;
    if (metrics.widthPixels < metrics.heightPixels){
        dpi = (int) (metrics.widthPixels / metrics.density);
    }
    else{
        dpi = (int) (metrics.heightPixels / metrics.density);
    }

    if (dpi < TABLET_MIN_DP_WEIGHT)         return true;
    else                                    return false;
}

और इस सूची में आप लोकप्रिय उपकरणों और टैबलेट के आकार की कुछ डीपी पा सकते हैं:

Wdp / Hdp

गैलेक्सी नेक्सस:
360/567 XOOM: 1280/752
गैलेक्सी नोट: 400/615
NEXUS 7: 961/528
गैलेक्सी टैक्सी (> 7 && <10): 1280/752
गैलेक्सी S3: 360/615

Wdp = चौड़ाई dp Hdp =
ऊँचाई dp

— Aracem
स्रोत
1

खैर, सबसे अच्छा समाधान जो मेरे लिए काम किया है वह काफी सरल है:

private boolean isTabletDevice(Resources resources) {   
    int screenLayout = resources.getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK;
    boolean isScreenLarge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_LARGE);
    boolean isScreenXlarge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_XLARGE);
    return (isScreenLarge || isScreenXlarge);
}

इस तरह इस्तेमाल किया:

public void onCreate(Bundle savedInstanceState) {
    [...]
    if (this.isTabletDevice(this.getResources()) == true) {
        [...]
    }
}

मैं वास्तव में पिक्सेल आकार को नहीं देखना चाहता, लेकिन केवल स्क्रीन के आकार पर निर्भर करता हूं।

नेक्सस 7 (LARGE) को टैबलेट के रूप में अच्छी तरह से जाना जाता है, लेकिन गैलेक्सी S3 (NORMAL) के रूप में नहीं।

— मैक्स
स्रोत
1

इस विधि का उपयोग करें जो डिवाइस के टेबलेट होने पर सही लौटे

public boolean isTablet(Context context) {  
    return (context.getResources().getConfiguration().screenLayout   
        & Configuration.SCREENLAYOUT_SIZE_MASK)    
        >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}
— Vyshnavi
स्रोत
यह समाधान उदाहरण के लिए एपीआई 18 और नेक्सस 7 1200 x 1920 xhdpi के साथ एक एमुलेटर पर काम नहीं कर रहा है!
— इंगू
यह अब कुछ उपकरणों पर काम नहीं करता है। उदाहरण के लिए यह सैमसंग मेगा डिवाइस के लिए गलत है
— bkurzius
हाँ .. यह अब काम नहीं करता है ... मैं वास्तव में प्रत्येक फ़ोल्डर मूल्यों, मानों के लिए सभी स्ट्रिंग फ़ाइल में बूलियन जोड़ने के लिए इस्तेमाल किया गया था, मान आदि <bool name = "TTablet "> झूठा </ bool> <bool नाम =" isLaritTablet "> गलत </ b>> और फिर जांचें कि क्या R.bool.isTablet यह खोजने के लिए सही है कि क्या डिवाइस टैबलेट है
— Vyshnavi
1

यदि स्क्रीन आकार का पता लगाने के नए उपकरणों पर सही मूल्य वापस नहीं आता है, तो एक कोशिश करें:

/*
 Returns '1' if device is a tablet
 or '0' if device is not a tablet.
 Returns '-1' if an error occured.
 May require READ_EXTERNAL_STORAGE
 permission.
 */
public static int isTablet()
{
    try
    {
        InputStream ism = Runtime.getRuntime().exec("getprop ro.build.characteristics").getInputStream();
        byte[] bts = new byte[1024];
        ism.read(bts);
        ism.close();

        boolean isTablet = new String(bts).toLowerCase().contains("tablet");
        return isTablet ? 1 : 0;
    }
    catch (Throwable t)
    {t.printStackTrace(); return -1;}
}

Android 4.2.2 पर परीक्षण किया गया (मेरी अंग्रेजी के लिए खेद है)

— BSTech
स्रोत
0

मुझे पता है कि यह सीधे आपके प्रश्न का उत्तर नहीं है, लेकिन यहां अन्य उत्तर स्क्रीन के आकार की पहचान करने का एक अच्छा विचार देते हैं। आपने अपने प्रश्न में लिखा है कि आपको झुकाव के साथ समस्याएं मिलीं और यह मेरे साथ भी हुआ।

यदि आप एक स्मार्टफोन पर जाइरोस्कोप (या रोटेशन सेंसर) चलाते हैं तो उस डिवाइस के डिफ़ॉल्ट ओरिएंटेशन के अनुसार x- और y- एक्सिस को टैबलेट की तुलना में अलग-अलग परिभाषित किया जा सकता है, (जैसे सैमसंग GS2 डिफ़ॉल्ट पोर्ट्रेट, सैमसंग GT-7310 है) डिफ़ॉल्ट परिदृश्य, नया Google Nexus 7 डिफ़ॉल्ट पोर्ट्रेट है, हालाँकि यह एक टैबलेट है!)।

अब यदि आप जाइरोस्कोप का उपयोग करना चाहते हैं, तो आप स्मार्टफ़ोन के लिए काम कर रहे समाधान के साथ समाप्त हो सकते हैं, लेकिन कुछ टैबलेट या अन्य तरीके से अक्ष-भ्रम।

यदि आप ऊपर से किसी एक समाधान का उपयोग केवल स्क्रीन-आकार के लिए करते हैं और फिर आवेदन करते हैं

SensorManager.remapCoordinateSystem(inputRotationMatrix, SensorManager.AXIS_X, 
    SensorManager.AXIS_Y, outputRotationMatrix);

अक्ष को फ़्लिप करने के लिए यदि इसमें एक बड़ी या बड़ी स्क्रीन आकार है तो यह 90% मामलों में काम कर सकता है लेकिन उदाहरण के लिए Nexus 7 पर यह परेशानी का कारण बनेगा (क्योंकि इसमें डिफ़ॉल्ट पोर्ट्रेट ओरिएंटेशन और एक बड़ी स्क्रीन-आकार है)।

इसे ठीक करने का सबसे सरल तरीका RotationVectorSample में प्रदान किया गया है जो आपके प्रदर्शन में sceenOrientation को सेट करके API डेमो के साथ जहाज nosensorदेता है:

<activity
    ...
    android:screenOrientation="nosensor">
...
</activity>
— अलेक्जेंडर पाचा
स्रोत
0

com.sec.feature.multiwindow.tablet पैकेज मैनेजर में केवल टैबलेट के लिए विशिष्ट है और com.sec.feature.multiwindow.phone फोन के लिए विशिष्ट है।

— RBz
स्रोत
0

नीचे विधि डिवाइस स्क्रीन की विकर्ण लंबाई की गणना करने के लिए तय करने के लिए है डिवाइस एक फोन या टैबलेट है। इस पद्धति के लिए एकमात्र चिंता यह है कि मौसम का निर्णय लेने के लिए थ्रेशोल्ड मान है कि डिवाइस टैबलेट है या नहीं। नीचे के उदाहरण में मैंने इसे 7 इंच और उससे अधिक के रूप में सेट किया।

public static boolean isTablet(Activity act)
{
    Display display = act.getWindow().getWindowManager().getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    float width = displayMetrics.widthPixels / displayMetrics.xdpi;
    float height = displayMetrics.heightPixels / displayMetrics.ydpi;

    double screenDiagonal = Math.sqrt( width * width + height * height );
    int inch = (int) (screenDiagonal + 0.5);
    Toast.makeText(act, "inch : "+ inch, Toast.LENGTH_LONG).show();
    return (inch >= 7 );
}
— MinFu
स्रोत
0 
public boolean isTablet() {
        int screenLayout = getResources().getConfiguration().screenLayout;
        return (Build.VERSION.SDK_INT >= 11 &&
                (((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) || 
                 ((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE)));
    }
— ज़ार ई अहमर
स्रोत
0

फोन और टैबलेट के बीच की रेखा खींचना कठिन होता जा रहा है। उदाहरण के लिए (अगस्त 2015 तक) सैमसंग मेगा 6.3 डिवाइस sw600dp फ़ोल्डरों से संसाधनों को खींचता है - जहां तक ​​एंड्रॉइड का संबंध है यह एक टैबलेट है।

@Vyshnavi का उत्तर उन सभी उपकरणों में काम करता है जिन्हें हमने परीक्षण किया है, लेकिन मेगा 6.3 के लिए नहीं।

@ हेल्टन इसाक उत्तर फोन के रूप में मेगा 6.3 लौटाता है - लेकिन चूंकि डिवाइस अभी भी sw600dp से संसाधनों को पकड़ता है, इसलिए यह अन्य मुद्दों का कारण बन सकता है - उदाहरण के लिए यदि आप फोन के लिए व्यूप्लेर का उपयोग करते हैं और टैबलेट के लिए नहीं तो आप एनपीई त्रुटियों के साथ हवा देंगे। ।

अंत में बस ऐसा लगता है कि जाँच करने के लिए बहुत अधिक शर्तें हैं और हमें बस यह स्वीकार करना पड़ सकता है कि कुछ फोन वास्तव में टैबलेट हैं :-P

— bkurzius
स्रोत
0

यह वह विधि है जिसका मैं उपयोग करता हूं:

public static boolean isTablet(Context ctx){    
    return = (ctx.getResources().getConfiguration().screenLayout 
    & Configuration.SCREENLAYOUT_SIZE_MASK) 
    >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}

का उपयोग करते हुए:

विन्यास। SCREENLAYOUT_SIZE_MASK

विन्यास। SCREENLAYOUT_SIZE_LARGE

यह अनुशंसित विधि है!

— Jorgesys
स्रोत
-1 के लिए स्पष्टीकरण? , यह google द्वारा पुनःप्राप्त एक विधि है।
— जोर्जेस
0

इसका उपयोग क्यों करें?

Use this method which returns true when the device is a tablet

public boolean isTablet(Context context) {  
return (context.getResources().getConfiguration().screenLayout   
    & Configuration.SCREENLAYOUT_SIZE_MASK)    
    >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}

मुझे कई तरीके दिखाई दे रहे हैं। कॉन्फ़िगरेशन क्लास को नीचे सही उत्तर मिला है:

    /**
 * Check if the Configuration's current {@link #screenLayout} is at
 * least the given size.
 *
 * @param size The desired size, either {@link #SCREENLAYOUT_SIZE_SMALL},
 * {@link #SCREENLAYOUT_SIZE_NORMAL}, {@link #SCREENLAYOUT_SIZE_LARGE}, or
 * {@link #SCREENLAYOUT_SIZE_XLARGE}.
 * @return Returns true if the current screen layout size is at least
 * the given size.
 */
public boolean isLayoutSizeAtLeast(int size) {
    int cur = screenLayout&SCREENLAYOUT_SIZE_MASK;
    if (cur == SCREENLAYOUT_SIZE_UNDEFINED) return false;
    return cur >= size;
}

बस कॉल करना :

 getResources().getConfiguration().
 isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE);

यह ठीक है?

— Longalei
स्रोत
0

मुझे केवल लेआउट फ़ाइल में स्मार्टफोन / टैबलेट का पता लगाने की आवश्यकता थी, क्योंकि मैं नेविगेशन कोड का उपयोग कर रहा हूं।

मैंने सबसे पहले एक लेआउट-स्व 600dp डायरेक्टरी बनाई थी, लेकिन यह अच्छी तरह से काम नहीं कर रही थी क्योंकि यह मेरे Nokia 8 को लैंडस्केप मोड में सक्रिय कर देगी, लेकिन स्क्रीन की ऊँचाई बहुत कम होगी।

इसलिए, मैंने निर्देशिका को लेआउट-स्व 600dp-h400dp के रूप में नाम दिया और फिर मुझे वांछित प्रभाव मिला। H-xxxdp पैरामीटर को इस बात पर निर्भर करना चाहिए कि आप अपने लेआउट पर कितनी सामग्री छोड़ना चाहते हैं और जैसे आवेदन निर्भर होना चाहिए।

— डोमिनिक लॉरे
स्रोत
-1

कृपया नीचे कोड देखें।

private boolean isTabletDevice() {
  if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb
    // test screen size, use reflection because isLayoutSizeAtLeast is
    // only available since 11
    Configuration con = getResources().getConfiguration();
    try {
      Method mIsLayoutSizeAtLeast = con.getClass().getMethod(
      "isLayoutSizeAtLeast", int.class);
      boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con,
      0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE
      return r;
    } catch (Exception x) {
      x.printStackTrace();
      return false;
    }
  }
  return false;
}
— सतीशबाबू एस
स्रोत
1
अब ICS के साथ मान्य नहीं है। वास्तव में,
— 11:57 से
1
यह विश्वसनीय नहीं है। नए आईसीएस फोन में एपीआई स्तर> 11.
— जेसन रॉबिन्सन
-1

मुझे लगता है कि एक टैबलेट की न्यूनतम और अधिकतम 600 पीएक्स चौड़ाई और ऊंचाई है,
इसलिए
मान प्राप्त करने के लिए स्क्रीन घनत्व और डीपी में ऊंचाई / चौड़ाई जानने की आवश्यकता है :

DisplayMetrics metrics = new DisplayMetrics();
activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
Display display = ((WindowManager)getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int width = display.getWidth(); 
int height = display.getHeight(); 
float density = metrics.density;  
if((width/density>=600 && height/density>=600))
 isTablette = true;
else
 isTablette = false;

— user1503892
स्रोत
यह सही नहीं है क्योंकि सैमसंग गैलेक्सी एस 3 का परिणाम 720 x 1280 है।
— निखिल
-1

फोन और टैबलेट के बीच में एक महत्वपूर्ण अंतर है (कम से कम मेरे कार्यक्रम के लिए)। यह डिवाइस का डिफ़ॉल्ट ओरिएंटेशन है। फोन में एक पोर्ट्रेट ओरिएंटेशन है, टैबलेट - लैंडस्केप। और डिवाइस को निर्धारित करने के लिए क्रमशः विधि:

private static boolean isLandscapeDefault(Display display) {
    Log.d(TAG, "isTablet()");
    final int width = display.getWidth();
    final int height = display.getHeight();

    switch (display.getOrientation()) {
    case 0: case 2:
        if(width > height) return true;
        break;
    case 1: case 3:
        if(width < height) return true;
        break;
    }
    return false;
}

EDITED: दान हुलमे के साथ चर्चा के बाद विधि का नाम बदल दिया।

— चांदी
स्रोत
1
सभी टैबलेट में डिफ़ॉल्ट लैंडस्केप ओरिएंटेशन नहीं है। और अगर "डिफ़ॉल्ट" अभिविन्यास आपके कार्यक्रम के लिए मायने रखता है, तो यह संभवतः अन्य तरीकों से गलत है। एक उदाहरण के लिए इस Android डेवलपर्स ब्लॉग पोस्ट देखें ।
— डैन हुल्मे
कृपया, क्या आप गोलियों के विशिष्ट उदाहरण दे सकते हैं, जो डिफ़ॉल्ट अभिविन्यास में चौड़ाई ऊंचाई से कम है? और निश्चित रूप से आप बेहतर जानते हैं कि मेरा ऐप क्या होना चाहिए: डी।
— चांदी
Nexus 7 एक उदाहरण होगा। लेकिन आपको इसके लिए मेरा शब्द नहीं लेना है: मेरे द्वारा लिंक किया गया लेख पढ़ें, जो यह सब बताता है।
— डैन हुल्मे
मुझे लगता है कि मुझे अपने तरीके का नाम बदलना चाहिए। वास्तव में, अधिक महत्वपूर्ण बात (कम से कम मेरे ऐप के लिए?) डिफ़ॉल्ट डिवाइस ओरिएंटेशन, और इस कार्य के लिए मेरी विधि पर्याप्त है। इसके अलावा समस्या को बहुत ही सही ढंग से पहचाना गया @ जवाब, ऊपर देखें।
— सिल्वर
-1

मैं एंड्रॉइड लाइब्रेरी 'कैफीन' की सिफारिश कर रहा हूं जिसमें फोन या टैबलेट शामिल हैं, और 10 इंच ~!

बहुत आसान उपयोग।

पुस्तकालय यहाँ है।

https://github.com/ShakeJ/Android-Caffeine-library

और उपयोग करें 

DisplayUtil.isTablet(this);
DisplayUtil.isTenInch(this);
— ShakeJ
स्रोत
-1

मेरे लिए फोन और टैबलेट के बीच अंतर डिवाइस और / या पिक्सेल घनत्व का आकार नहीं है, जो प्रौद्योगिकी और स्वाद के साथ बदल जाएगा, बल्कि स्क्रीन अनुपात। यदि मैं पाठ की एक स्क्रीन प्रदर्शित कर रहा हूं, तो मुझे पता होना चाहिए कि क्या, कहने के लिए, 15 लंबी लाइनों (फोन) बनाम 20 छोटी लाइनों (टैबलेट) की आवश्यकता है। मेरे खेल के लिए मैं आयत के बॉलपार्क के आकलन के लिए निम्नलिखित का उपयोग करता हूं, मेरा सॉफ्टवेयर इससे निपटेगा:

    Rect surfaceRect = getHolder().getSurfaceFrame();
    screenWidth = surfaceRect.width();
    screenHeight = surfaceRect.height();
    screenWidthF = (float) screenWidth;
    screenHeightF = (float) screenHeight;
    widthheightratio = screenWidthF/screenHeightF;
    if(widthheightratio>=1.5) {
        isTablet=false;
    }else {
        isTablet=true;
    }
— Androidcoder
स्रोत
-3

मुझे लगता है कि यह ईमानदार होने का सबसे आसान तरीका है। यह स्क्रीन आकार की जाँच करेगा जिसका उपयोग किया जा रहा है:

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

शुभकामनाएँ!

— Otroberts
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.