¿Determinar si el dispositivo es un teléfono inteligente o una tableta? [duplicar]
Me gustaría obtener información sobre un dispositivo para ver si es un teléfono inteligente o una tableta. ¿Cómo puedo hacerlo?
Me gustaría mostrar diferentes páginas web de recursos según el tipo de dispositivo:
String s="Debug-infos:";
s += "\n OS Version: " + System.getProperty("os.version") + "(" + android.os.Build.VERSION.INCREMENTAL + ")";
s += "\n OS API Level: " + android.os.Build.VERSION.SDK;
s += "\n Device: " + android.os.Build.DEVICE;
s += "\n Model (and Product): " + android.os.Build.MODEL + " ("+ android.os.Build.PRODUCT + ")";
Sin embargo, parece inútil para mi caso.
Esta solución me funciona ahora:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int width = metrics.widthPixels;
int height = metrics.heightPixels;
if (SharedCode.width > 1023 || SharedCode.height > 1023){
//code for big screen (like tablet)
}else{
//code for small screen (like smartphone)
}
Este tema se trata en la Capacitación de Android:
Utilice el calificador de ancho más pequeño
Si lees el tema completo, explican cómo establecer un valor booleano en un archivo de valores específico (como res/values-sw600dp/attrs.xml):
<resources>
<bool name="isTablet">true</bool>
</resources>
Porque el calificador sw600dp solo es válido para plataformas superiores a Android 3.2. Si desea asegurarse de que esta técnica funcione en todas las plataformas (antes de 3.2), cree el mismo archivo en la carpeta res/values-xlarge:
<resources>
<bool name="isTablet">true</bool>
</resources>
Luego, en el archivo de valores "estándar" (como res/values/attrs.xml), configura el valor booleano en falso:
<resources>
<bool name="isTablet">false</bool>
</resources>
Luego, en su actividad, puede obtener este valor y verificar si está ejecutando en un dispositivo del tamaño de una tableta:
boolean tabletSize = getResources().getBoolean(R.bool.isTablet);
if (tabletSize) {
// do something
} else {
// do something else
}
Considero que una tablet tiene al menos una pantalla de 6,5 pulgadas. Así es como se calcula, según la respuesta anterior de Nolf.
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 realizar 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., esta es realmente una pregunta diferente.
Además, si bien el uso de la resolución de pantalla, o la gestión de recursos grande versus extragrande, puede haber sido un enfoque válido en el pasado, los nuevos dispositivos 'móviles' ahora vienen con pantallas tan grandes y resoluciones tan altas que desdibujan esta línea, mientras que si realmente lo desea Para saber si hay capacidad de llamada telefónica o no, lo 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, descubrí que no siempre es tan simple, con nuevos dispositivos y pantallas que aparecen constantemente, y quiero ser un poco más "granular" al tratar de determinar el tamaño real de la pantalla. . Otra solución que encontré aquí por John utiliza un recurso String, en lugar de un valor booleano, para especificar el tamaño de la tableta. Entonces, en lugar de simplemente poner true en un archivo /res/values-sw600dp/screen.xml (asumiendo que aquí es donde están sus diseños para tabletas pequeñas), colocaría:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="screen_type">7-inch-tablet</string>
</resources>
Consúltelo de la siguiente manera y luego haga lo que necesite según 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 tabletas de 7 y 10 pulgadas mediante programación también era lo que estaba buscando. Es posible que desees comprobarlo si las respuestas aquí no te permiten ser tan específico como quisieras. Hace un gran trabajo al explicar cómo calcular diferentes métricas para descubrir con qué estás lidiando realmente.
ACTUALIZAR
Al mirar el código fuente de la aplicación Google I/O 2013, encontré lo siguiente que usan para identificar si el dispositivo es una tableta o no, así que pensé en agregarlo. Lo anterior te da un poco más de "control" sobre ella, pero si sólo 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;
}
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;
}
