दिलचस्प पोस्ट
"क्षेत्र प्रवासन की आवश्यकता", एंड्रॉइड में अपवाद जबकि realm db से मूल्य प्राप्त करना एब्बटटेबल मॉडेल का उपयोग करते हुए JTable में चयनित पंक्तियाँ प्राप्त करें क्रोम डेवलपमेंट टूल: जावास्क्रिप्ट से फाइल मैं जावास्क्रिप्ट में कोड की एक से अधिक पंक्ति में स्ट्रिंग कैसे तोड़ूंगा? कैसे कमांड लाइन से एक्सएमएल प्रिंट करने के लिए? पीथोन: एक शब्दकोश में ट्यूपल्स की सूची परिवर्तित करना क्रेडिट कार्ड इनपुट के लिए एक यूआईटीडेफिल्ड फॉर्मेट करना (xxxx xxxx xxxx xxxx) क्या एक लेनदेन (एसक्यूएल सर्वर के अंदर) में कई डीडीएल विवरण चलाना संभव है? OAuth 2 से OAuth 2 अलग कैसे है? गतिशील एसक्यूएल (पैरामीटर के रूप में तालिका का नाम देना) जावास्क्रिप्ट बिना स्ट्रैटेबल के अंदर स्ट्रैटेबल – जैसे PHP विजुअल स्टूडियो 2010 के लिए क्यूटी कैसे तैयार करें वेब ब्राउज़र को पुश नोटिफिकेशन कैसे भेजना है? कैसे "जैसे" के साथ MongoDB क्वेरी करने के लिए? इंटरफ़ेस या एक सार वर्ग: उपयोग करने के लिए कौन सा?

टैबलेट या फोन – एंड्रॉइड

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

वेब के समाधान से एकत्रित समाधान "टैबलेट या फोन – एंड्रॉइड"

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

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

उदाहरण:

फ़ाइल res/values/screen.xml ( res/values/screen.xml res/layout/ संभालने 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/ res/values-sw600dp/screen.xml संभालने res/layout-sw600dp/ इसमें res/layout-sw600dp/ 7 जैसी छोटी res/layout-sw600dp/ लिए लेआउट फाइलें हैं)

 <?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/ 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 निरंतर के माध्यम से पहुंच योग्य है।

यह पता लगाने के लिए कि डिवाइस टेबलेट है, निम्न कोड का उपयोग करता है:

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

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

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

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

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

मुझे इसकी पहचान करने की जरूरत है कि मेरा डिवाइस एक टैबलेट या फोन था, जिसके साथ मैं स्क्रीन के तर्क को लागू कर सकूं। और मेरे विश्लेषण में एमडीपीआई से शुरू होने वाला टैबलेट 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; } 

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

 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 इंच या उससे कम होना चाहिए।

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

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

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

 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/15/android-accelerometer/ से । मैंने इसे परीक्षण नहीं किया है)

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

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

 TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){ return "Tablet"; }else{ return "Mobile"; } 

रॉबर्ट डेल जॉनसन 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 } 

उन लोगों के लिए जो Google के कोड का निर्धारण करना चाहते हैं कि कौन से डिवाइस एक टैबलेट UI का उपयोग करेगा, नीचे का उल्लेख कर सकते हैं:

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

यह विधि Google द्वारा सुझाई गई है मैं यह कोड Google Offical Android ऐप में iosched

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

"नया" स्वीकृत निर्देशिकाओं (उदाहरणों के लिए values-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; } 

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

डब्ल्यूडीपी / एचडीपी

आकाशगंगा नेक्सस: 360/567
एक्सओएम: 1280/752
गैलेक्सी नोट: 400/615
नेक्सस 7: 961/528
गैलेक्सी टैब (> 7 && <10): 1280/752
आकाशगंगा एस 3: 360/615

Wdp = चौड़ाई डीपी
एचडीपी = ऊंचाई डीपी

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

 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 (लार्ज) को एक टैबलेट के रूप में अच्छी तरह से काम करता है, लेकिन गैलेक्सी एस 3 (सामान्य) नहीं।

इस पद्धति का उपयोग करें, जो डिवाइस को एक टैबलेट के साथ सही कर देता है

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

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

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

एंड्रॉइड 4.2.2 पर परीक्षण (मेरी अंग्रेजी के लिए खेद है।)

कोई कोड आवश्यक नहीं है

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

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

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

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

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

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

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

टिप्पणियाँ

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

Android डॉक्स पढ़ने योग्य है

  • एकाधिक स्क्रीन का समर्थन करना
  • विभिन्न स्क्रीन आकारों का समर्थन करना
  • विशिष्ट स्क्रीन को वितरित करना

यदि आप केवल API स्तर> = 13 को लक्षित कर रहे हैं तो कोशिश करें

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

चीयर्स 🙂

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

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

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

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

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

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

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

 <activity ... android:screenOrientation="nosensor"> ... </activity> 

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

नीचे विधि डिवाइस स्क्रीन की विकर्ण लंबाई की गणना करने के लिए डिवाइस एक फोन या टैबलेट तय है। इस पद्धति का एकमात्र चिंता यही है कि मौसम तय करने के लिए थ्रेशोल्ड मान टैबलेट है या नहीं। नीचे दिए गए उदाहरण में मैं इसे 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 ); } 
 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))); } 

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

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

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

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

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

 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

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

मेरे लिए फोन और टैबलेट के बीच का अंतर डिवाइस और / या पिक्सेल घनत्व का आकार नहीं है, जो प्रौद्योगिकी और स्वाद के साथ बदल जाएगा, बल्कि स्क्रीन अनुपात। अगर मैं पाठ की एक स्क्रीन प्रदर्शित कर रहा हूं तो मुझे यह जानने की जरूरत है कि, कहें, 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; } 

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

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

मुझे लगता है कि एक टैबलेट में न्यूनतम और अधिकतम 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; 

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

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

संपादित किया गया: दान हूल के साथ हुई बातचीत के बाद विधि का नाम बदल दिया गया।

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

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

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

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

और उपयोग करें

 DisplayUtil.isTablet(this); DisplayUtil.isTenInch(this); 

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

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

शुभकामनाएँ!