Determinar si el dispositivo es un teléfono inteligente o tableta? [duplicar]

Considero que una tableta tiene al menos una pantalla de 6.5 pulgadas. Esta es la forma de calcularlo, basado en la respuesta de Nolf anterior.

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

float yInches= metrics.heightPixels/metrics.ydpi;
float xInches= metrics.widthPixels/metrics.xdpi;
double diagonalInches = Math.sqrt(xInches*xInches + yInches*yInches);
if (diagonalInches>=6.5){
    // 6.5inch device or bigger
}else{
    // smaller device
}

Mi suposición es que cuando define 'Móvil/Teléfono' desea saber si puede hacer una llamada telefónica en el dispositivo que no se puede hacer en algo que se definiría como una 'Tableta'. La forma de verificar esto está a continuación. Si desea saber algo basado en sensores, tamaño de pantalla, etc, entonces esta es realmente una pregunta diferente.

También, mientras se utiliza la resolución de pantalla, o la gestión de recursos grande vs xlarge, puede haber sido un enfoque válido en el pasado nuevos dispositivos 'Móviles' son ahora viene con pantallas tan grandes y altas resoluciones que están difuminando esta línea, mientras que si realmente desea saber la capacidad de llamada telefónica vs sin llamada telefónica, la siguiente es "mejor".

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

Me gusta la solución de Ol_v_er y su simplicidad sin embargo, he encontrado que no siempre es tan simple, con nuevos dispositivos y pantallas que salen constantemente, y quiero ser un poco más "granular" al tratar de averiguar el tamaño real de la pantalla. Otra solución que encontré aquí por John usa un recurso de cadena, en lugar de un booleano, para especificar el tamaño de la tableta. Por lo tanto, en lugar de solo poner true en a /res/valores-sw600dp/pantalla.archivo xml (suponiendo que aquí es donde están sus diseños para tabletas pequeñas) usted pondría:

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

Referencialo como sigue y luego haz lo que necesites basado en el resultado:

String screenType = getResources().getString(R.string.screen_type);
if (screenType.equals("7-inch-tablet")) {
    // do something
} else {
    // do something else
}

La respuesta de Sean O'Toole para Detectar 7 pulgadas y 10 pulgadas tableta programáticamente también era lo que estaba buscando. Es posible que desee comprobar que hacia fuera si las respuestas aquí no le permiten ser tan específico como le gustaría. Él hace un gran trabajo de explicar cómo calcular diferentes métricas para averiguar lo que realmente está tratando con.

ACTUALIZACIÓN

Al mirar el código fuente de la aplicación Google I/O 2013, me encontré con lo siguiente que usan para identificar si el dispositivo es una tableta o no, así que pensé que lo agregaría. Lo anterior te da un poco más de "control" sobre él, pero si solo quieres saber si es una tableta, lo siguiente es bastante simple:

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

Dado que las tabletas son en general más grandes que los teléfonos inteligentes y dado que una tableta de baja resolución puede tener el mismo número de píxeles que un teléfono inteligente de alta resolución, una forma de resolver esto es calcular el TAMAÑO físico (no la resolución) de un dispositivo:

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

    float yInches= metrics.heightPixels/metrics.ydpi;
    float xInches= metrics.widthPixels/metrics.xdpi;

   if (yInches> smallestTabletSize|| xInches > smallestTabletSize)
    {
                  //We are on a 
    }

La mejor opción que encontré y la menos intrusiva, es establecer un parámetro de etiqueta en tu xml, como

DISEÑO XML DEL TELÉFONO

<android.support.v4.view.ViewPager xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/pager"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:tag="phone"/>

DISEÑO XML DE LA TABLETA

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/pager"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:tag="tablet">

    ...

</RelativeLayout>

Y luego llama a esto en tu clase de actividad:

View viewPager = findViewById(R.id.pager);
Log.d(getClass().getSimpleName(), String.valueOf(viewPager.getTag()));

Espero que funcione para u.

Utilizo este método en todas mis aplicaciones, y funciona correctamente:

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

La solución que utilizo es definir dos layouts. Uno con la carpeta de diseño establecida en, por ejemplo diseño-sw600dp Uso esto para proporcionar un botón de menú para los usuarios de mi tableta y para ocultar esto para los usuarios de teléfonos. De esa manera no tengo (todavía) que implementar la barra de acción para mis aplicaciones existentes ...

Ver este post para más detalles.

Re: la tangente anterior sobre cómo distinguir un teléfono de un no-teléfono: por lo que sé, solo un teléfono tiene un IMEI (International Mobile Station Equipment Identity) de 15 dígitos, por lo que el siguiente código distinguirá definitivamente un teléfono de un no-teléfono:

    TelephonyManager manager = (TelephonyManager) this.getSystemService(Context.TELEPHONY_SERVICE);
    String deviceInfo = "";
    deviceInfo += manager.getDeviceId(); // the IMEI
    Log.d(TAG, "IMEI or unique ID is " + deviceInfo);

    if (manager.getDeviceId() == null) {
        Log.d(TAG, "This device is NOT a phone");
    } else {
        Log.d(TAG, "This device is a phone.");
    }

He encontrado que en un emulador de Nook getPhoneType() devuelve un tipo de teléfono de "GSM" por alguna razón, por lo que parece que comprobar el tipo de teléfono no es confiable. Del mismo modo, getNetworkType() devolverá 0 para un teléfono en modo avión. En de hecho, el modo airplane hará que getLine1Number () y los métodos getSim* devuelvan null también. Pero incluso en modo avión, el IMEI de un teléfono persiste.