Kullanıcının tablet mi yoksa telefon mu kullandığını kontrol etmenin bir yolu var mı? Eğim işlevim ve yeni tabletim (Transformer) ile ilgili sorun yaşıyorum

Daha önce de belirtildiği gibi, cihazın bir tablet mi yoksa bir telefon mu olduğunu kontrol etmek istemiyorsunuz, ancak cihazın özelliklerini öğrenmek istiyorsunuz,

Çoğu zaman, bir tablet ve telefon arasındaki fark ekran boyutudur, bu nedenle farklı düzen dosyaları kullanmak istersiniz. Bu dosyalar res/layout-<qualifiers>dizinlerde saklanır . Her düzeniniz res/values-<same qualifiers>için dizinde bir XML dosyası oluşturabilir ve kullandığınız düzenleri ayırt etmek için bir int / bool / string kaynağı koyabilirsiniz.

Misal:

Dosya res/values/screen.xml( res/layout/el cihazları için düzen dosyalarınızı içerdiği varsayılarak )

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

Dosya res/values-sw600dp/screen.xml( res/layout-sw600dp/Nexus 7 gibi küçük tabletler için düzen dosyalarınızı içerdiği varsayılarak )

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

Dosya res/values-sw720dp/screen.xml( res/layout-sw720dp/Nexus 10 gibi büyük tabletler için düzen dosyalarınızı içerdiği varsayılarak ):

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

Artık ekran tipine R.string.screen_typesabit üzerinden erişilebilir .

Cihazın tablet olup olmadığını tespit etmek için aşağıdaki kodu kullanın:

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

BÜYÜK ve XLARGE Ekran Boyutları, kullanılacakları gözden olan mesafeye (dolayısıyla bir tablet fikri) göre üretici tarafından belirlenir.

Daha fazla bilgi: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Bu yazı bana çok yardımcı oldu,

Ne yazık ki bana yardımcı olan tüm cevapları değerlendirmek için gerekli itibara sahip değilim.

Cihazımın bir tablet mi yoksa bir telefon mu olduğunu belirlemem gerekiyordu, bununla birlikte ekran mantığını uygulayabiliyordum. Ve analizimde, tablet MDPI'den başlayarak 7 inçten (Xlarge) fazla olmalıdır.

İşte bu yazıyı temel alarak oluşturulan aşağıdaki kod.

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

Neden ekranın boyutunu köşegen olarak hesaplamıyorsunuz ve bunu cihazın bir telefon veya tablet olup olmadığına karar vermek için kullanmıyorsunuz?

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

Tabii ki eşiğin 9 inç veya daha az olması gerektiği iddia edilebilir.

hiçbir fark yok. Farkı düşündüğünüzü tanımlamalı ve kontrol etmelisiniz. Bir galaksi sekmesi bir telefon mu? ya da bir tablet? ve neden?

Aradığınız belirli özellikleri ve kodunu tanımlamalısınız.

Görünüşe göre 'eğim' arıyorsunuz. Bu ivmeölçer ile aynı olduğunu düşünüyorum (bu bir kelime mi?). Sadece aşağıdakileri kullanarak cihazın destekleyip desteklemediğini kontrol edebilirsiniz:

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/ adresinden . test etmedim)

Benim varsayımım, 'Mobil / Telefon' tanımladığınızda, cihazda 'Tablet' olarak tanımlanacak bir şey üzerinde yapılamayan bir telefon görüşmesi yapıp yapamayacağınızı bilmek istemenizdir. Bunu doğrulamanın yolu aşağıdadır. Sensörlere, ekran boyutuna vb. Dayalı bir şey bilmek istiyorsanız, bu gerçekten farklı bir soru.

Ayrıca, ekran çözünürlüğü veya xlarge'ye karşı büyük kaynak yönetimini kullanırken, geçmişte yeni bir 'Mobil' cihazlar şimdi çok büyük ekranlar ve yüksek çözünürlüklerle geliyor olabilir. telefon görüşmesi vs hiçbir telefon görüşmesi yeteneği bilmek aşağıda 'en iyi'.

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

Robert Dale Johnson III ve Helton Isac'a dayanarak bu kod ile geldim Umarım bu yararlıdır

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

Kodunuzda şöyle bir filtre yapın:

if(isTabletDevice(Utilities.this) && isTablet(Utilities.this)){
    //Tablet
} else {
    //Phone
}

Google IOSched 2017 uygulama kaynak kodunda aşağıdaki yöntem kullanılır:

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

Google'ın hangi cihazların Tablet kullanıcı arayüzü kullanacağına karar verme koduna başvurmak isteyenler için aşağıdakilere başvurabilirsiniz:

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

Bu yöntem Google tarafından tavsiye edilir. Bu kodu Google Resmi Android Uygulaması'nda görüyorumiosched

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

Kod gerekmez

Diğer cevaplar, cihazın bir telefon veya tablet olup olmadığını programlı olarak belirlemenin birçok yolunu listeler. Ancak, belgeleri okursanız çeşitli ekran boyutlarını desteklemeniz için önerilen yol bu değildir.

Bunun yerine, tabletler veya telefonlar için farklı kaynaklar bildirin. Sen bu benim ekleyerek ek kaynak klasörler yapmak layout, valuesvb

• Android 3.2 (API seviye 13) için bir sw600dpklasör ekleyin . Bu araçlar s mallest ağırlık IDþ yaklaşık telefon / tablet bölme olan, en az 600dp olup. Ancak, başka boyutlar da ekleyebilirsiniz. Ek düzen kaynak dosyasının nasıl ekleneceğine ilişkin bir örnek için bu cevaba göz atın .

• Ayrıca Android 3.2 öncesi cihazları da destekliyorsanız, tabletleri desteklemek için klasör largeveya xlargeklasör eklemeniz gerekir . (Telefonlar genellikle smallve normal.)

Farklı ekran boyutları için ekstra bir xml dosyası ekledikten sonra kaynaklarınızın neye benzeyebileceğini gösteren bir resim.

Bu yöntemi kullanırken, sistem sizin için her şeyi belirler. Hangi cihazın çalışma zamanında kullanıldığından endişelenmenize gerek yoktur. Sadece uygun kaynakları sağlar ve Android'in tüm işi yapmasına izin verirsiniz.

notlar

• Aynı kaynak dosyalarını çoğaltmamak için takma adlar kullanabilirsiniz .

Okumaya değer Android belgeleri

• Birden Çok Ekranı Destekleme
• Farklı Ekran Boyutlarını Destekleme
• Belirli Ekranlara Dağıtma

Yalnızca API düzeyi> = 13'ü hedefliyorsanız,

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

şerefe :-)

"Yeni" kabul edilen dizinler üzerinde düşünme (örneğin değerleri-sw600dp) ekranın genişliği DP dayalı bu yöntemi oluşturdu:

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

Ve bu listede popüler cihazların ve tablet boyutlarının DP'sinden bazılarını bulabilirsiniz:

Wdp / Hdp

GALAXY Nexus:
360/567 XOOM: 1280/752
GALAXY NOT: 400/615
NEXUS 7: 961/528
GALAXY SEKMESİ (> 7 && <10): 1280/752
GALAXY S3: 360/615

Wdp = Genişlik dp
Hdp = Yükseklik dp

Benim için işe yarayan en iyi çözüm oldukça basit:

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

Bunun gibi kullanılır:

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

Gerçekten piksel boyutlarına bakmak istemiyorum ama sadece ekran boyutuna güveniyorum.

Nexus 7 (BÜYÜK) bir tablet olarak algılanır, ancak Galaxy S3 (NORMAL) tarafından iyi algılanmaz.

Cihaz bir tablet olduğunda true değerini döndüren bu yöntemi kullanın

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

Ekran boyutu algılaması yeni cihazlarda doğru değeri döndürmezse, bir deneyin:

/*
 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'de test edildi (İngilizcem için üzgünüm.)

Bunun doğrudan sorunuza bir cevap olmadığını biliyorum, ancak buradaki diğer cevaplar ekran boyutunu nasıl tanımlayacağınız konusunda iyi bir fikir veriyor. Sorunuzda eğim ile ilgili sorunlarınız olduğunu yazdınız ve bu da bana da oldu.

Jiroskopu (veya dönüş sensörünü) bir akıllı telefonda çalıştırırsanız, x ve y ekseni bir tabletten farklı olarak tanımlanabilir, bu cihazın varsayılan yönüne göre (örn. Samsung GS2 varsayılan portre, Samsung GT-7310 varsayılan manzara, yeni Google Nexus 7, bir tablet olmasına rağmen varsayılan portre!).

Şimdi Gyroskop kullanmak istiyorsanız, akıllı telefonlar için çalışan bir çözümle sonuçlanabilir, ancak bazı tabletlerde eksen karışıklığı veya başka bir yolla karşılaşabilirsiniz.

Yukarıdaki ekranlardan birini yalnızca ekran boyutuna gitmek ve ardından uygulamak için kullanırsanız

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

büyük veya xlarge ekran boyutuna sahipse ekseni çevirmek bu durumların% 90'ında işe yarayabilir, ancak Nexus 7'de sorunlara neden olur (varsayılan dikey yönlendirmeye ve büyük ekran boyutuna sahip olduğundan).

Bunu düzeltmenin en basit yolu nosensor, manifesto'nuzda sceenOrientation öğesini ayarlayarak API demolarıyla birlikte gönderilen RotationVectorSample öğesinde sağlanır :

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

Paket yöneticisindeki com.sec.feature.multiwindow.tablet yalnızca tablete, com.sec.feature.multiwindow.phone ise telefona özeldir.

Aşağıdaki yöntem, cihazın bir telefon veya tablet olduğuna karar vermek için cihaz ekranının çapraz uzunluğunu hesaplamaktır. bu yöntemin tek endişesi, cihazın hava olup olmadığı konusunda karar vermek için eşik değerinin ne olduğudur. Aşağıdaki örnekte 7 inç ve üstü olarak ayarladım.

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

Telefon ve tablet arasındaki hattı çizmek gittikçe zorlaşıyor. Örneğin (Ağu 2015 itibariyle) Samsung Mega 6.3 cihazı, sw600dp klasörlerinden kaynakları çekiyor - Android söz konusu olduğunda bir tablet.

@Vyshnavi'den cevap test ettiğimiz ancak Mega 6.3 için olmayan tüm cihazlarda çalışıyor.

@Helton Isac yanıtı Mega 6.3'ü bir telefon olarak döndürür - ancak cihaz hala sw600dp'den kaynak aldığından başka sorunlara neden olabilir - örneğin, tabletler için değil, telefonlar için bir görüntüleyici kullanırsanız, NPE hatalarıyla dolanırsınız .

Sonunda kontrol etmek için çok fazla koşul var gibi görünüyor ve bazı telefonların aslında tablet olduğunu kabul etmemiz gerekebilir:

Ben kullandığım yöntem budur:

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

Kullanımı:

Yapılandırma. SCREENLAYOUT_SIZE_MASK

Yapılandırma. SCREENLAYOUT_SIZE_LARGE

Önerilen yöntem budur!

neden kullanıyorsun?

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

yukarıdaki birçok yol görüyorum.Yapılandırma sınıfı hemen aşağıda doğru cevabı aldı:

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

sadece ara :

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

tamam?

Gezinme kodunu kullandığım için akıllı telefonu / tableti yalnızca düzen dosyasında algılamam gerekiyordu.

İlk yaptığım, bir düzen-sw600dp dizini oluşturmaktı, ancak Nokia 8 cihazımda yatay modda etkinleştirileceği için ekranın çok küçük olacağı için iyi çalışmıyor.

Bu yüzden, dizini layout-sw600dp-h400dp olarak yeniden adlandırdım ve sonra istenen efekti aldım. H-xxxdp parametresi, mizanpajınıza ne kadar içerik bırakmak istediğinize bağlı olmalıdır ve bu nedenle uygulamaya bağlı olmalıdır.

Lütfen aşağıdaki kodu kontrol edin.

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

Bir tabletin min ve max 600 piksel genişlik ve yüksekliğe sahip olduğunu düşünüyorum,
bu yüzden
değeri almak için ekran yoğunluğunu ve dp cinsinden yükseklik / genişliği bilmeniz gerekir :

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;

Telefon ve tablet arasında önemli bir fark var (en azından programım için). Cihazın varsayılan yönüdür. Telefonun dikey bir yönü vardır, tablet - manzara. Ve sırasıyla cihazı belirleme yöntemi:

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

DÜZENLENEN: Dan Hulme ile yapılan tartışmaların ardından yöntemin adını değiştirdi.

Ben android kütüphane 'kafein' tavsiye ederim İçeren olsun Telefon veya tablet, ve 10 inç ~!

çok kolay kullanım.

kütüphane burada.

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

ve kullan

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

Benim için telefon ve tablet arasındaki fark, cihaz boyutu ve / veya piksel yoğunluğu değil, teknoloji ve zevkle değişecek, daha çok ekran oranı. Bir metin ekranı görüntülüyorsam, 15 uzun satırın (telefon) vs 20 daha kısa satırın (tablet) olup olmadığını bilmem gerekir. Oyunum için, yazılımımın ele alacağı dikdörtgenin basketbol sahası tahmininde aşağıdakileri kullanıyorum:

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

Dürüst olmanın en kolay yolu bu bence. Bu, kullanılan ekran boyutunu kontrol edecektir:

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

İyi şanslar!