Tablet o teléfono – Android

¿Hay alguna manera de comprobar si el usuario está usando una tableta o un teléfono? Tengo problemas con mi función de inclinación y mi nueva tableta (Transformer)

26 Solutions collect form web for “Tablet o teléfono – Android”

Como se ha mencionado antes, no desea comprobar si el dispositivo es una tableta o un teléfono, pero desea conocer las características del dispositivo,

La mayoría de las veces, la diferencia entre una tableta y un teléfono es el tamaño de la pantalla, que es la razón por la que desea utilizar diferentes archivos de diseño. Estos archivos se almacenan en los directorios res/layout-<qualifiers> . Puede crear un archivo XML en el directoy res/values-<same qualifiers> para cada uno de sus diseños y poner un recurso int / bool / string en él para distinguir entre los diseños que utiliza.

Ejemplo:

Archivo res/values/screen.xml (asumiendo res/layout/ contiene los archivos de diseño para los teléfonos)

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

Archivo res/values-sw600dp/screen.xml (asumiendo res/layout-sw600dp/ contiene los archivos de diseño para pequeñas tabletas como el Nexus 7)

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

Archivo res/values-sw720dp/screen.xml (asumiendo res/layout-sw720dp/ contiene los archivos de diseño para tablets grandes como el Nexus 10):

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

Ahora el tipo de pantalla es accesible a través de la constante R.string.screen_type .

Para detectar si el dispositivo es una tableta utilice el código siguiente:

 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 y XLARGE Los tamaños de la pantalla son determinados por el fabricante basado en la distancia desde el ojo que se va a utilizar en (por lo tanto, la idea de una tableta).

Más información: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Este post me ayudó mucho,

Desafortunadamente no tengo la reputación necesaria para evaluar todas las respuestas que me ayudaron.

Necesitaba identificar si mi dispositivo era una tableta o un teléfono, con eso sería capaz de implementar la lógica de la pantalla. Y en mi análisis de la tableta debe ser más de 7 pulgadas (Xlarge) a partir de MDPI.

Aquí está el código de abajo, que fue creado con base en esta publicación.

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

¿Por qué no calcular el tamaño de la diagonal de la pantalla y utilizarlo para tomar la decisión de si el dispositivo es un teléfono o una tableta?

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

Por supuesto uno puede discutir si el umbral debe ser 9 pulgadas o menos.

no hay diferencia. Usted debe definir lo que usted piensa que es la diferencia, y comprobar que. ¿Es una pestaña de galaxias un teléfono? O una tableta? ¿y por qué?

Debe definir las características específicas que está buscando y el código para eso.

Parece que usted está buscando 'inclinación'. Creo que esto es lo mismo que el acelerómetro (es que una palabra?). Sólo puede comprobar si el dispositivo lo admite, utilizando:

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

(De http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . No lo he probado)

Mi suposición es que cuando defina '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 define como un 'Tablet'. La forma de verificar esto es a continuación. Si desea saber algo basado en sensores, tamaño de pantalla, etc, entonces esto es realmente una pregunta diferente.

Además, si bien el uso de la resolución de pantalla, o la gestión de recursos grandes vs xlarge, puede haber sido un enfoque válido en el pasado nuevos dispositivos "móviles" ahora vienen con pantallas tan grandes y de alta resolución que están difuminando esta línea, Para saber la llamada de teléfono vs ninguna capacidad de 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"; } 

Basado en Robert Dale Johnson III y Helton Isac me llegó con este código Espero que esto sea útil

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

Así que en tu código haz un filtro como

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

Para aquellos que deseen consultar el código de Google para decidir qué dispositivos utilizarán una interfaz de usuario de Tablet, puede consultar a continuación:

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

Este método es una recomendación de Google. Veo este código en Google Offical Android App iosched

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

Pensando en el "nuevo" acepted directorios (valores-sw600dp por ejemplo) i creado este método basado en la pantalla de la anchura DP:

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

Y en esta lista puede encontrar algunos de los DP de dispositivos populares y tamaños de tabletas:

Wdp / Hdp

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

Wdp = Anchura dp
Hdp = Altura dp

Bueno, la mejor solución que funcionó para mí es bastante simple:

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

Se utiliza de esta manera:

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

Realmente no quiero mirar los tamaños de píxeles, pero sólo se basan en el tamaño de la pantalla.

Funciona bien como Nexus 7 (LARGE) se detecta como una tableta, pero no Galaxy S3 (NORMAL).

Utilice este método que devuelve true cuando el dispositivo es una tableta

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

Si la detección del tamaño de la pantalla no devuelve el valor correcto en los dispositivos más recientes, pruebe:

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

Probado en Android 4.2.2 (lo siento por mi inglés.)

No se necesita código

Las otras respuestas enumeran muchas formas de determinar mediante programación si el dispositivo es un teléfono o una tableta. Sin embargo, si lee la documentación , no es la forma recomendada de admitir varios tamaños de pantalla.

En su lugar, declare diferentes recursos para tabletas o teléfonos. Haces esto añadiendo carpetas de recursos adicionales para layout , values , etc.

  • Para Android 3.2 (API nivel 13), agregue una carpeta sw600dp . Esto significa que el tamaño de la pantalla es de al menos 600dp, que es aproximadamente la división de teléfono / tableta. Sin embargo, también puede agregar otros tamaños también. Echa un vistazo a esta respuesta para ver un ejemplo de cómo agregar un archivo de recursos de diseño adicional.

  • Si también está apoyando los dispositivos pre Android 3.2, tendrá que agregar carpetas large o xlarge para admitir tablets. (Los teléfonos suelen ser small y normal .)

Aquí hay una imagen de lo que sus recursos pueden gustar después de agregar un extra xml archivos para diferentes tamaños de pantalla.

Introduzca aquí la descripción de la imagen

Al utilizar este método, el sistema lo determina todo para usted. No tiene que preocuparse acerca de qué dispositivo se está utilizando en tiempo de ejecución. Usted acaba de proporcionar los recursos adecuados y dejar Android hacer todo el trabajo.

Notas

  • Puede utilizar alias para evitar la duplicación de archivos de recursos idénticos.

Documentos Android vale la pena leer

  • Soporte de varias pantallas
  • Soporte de diferentes tamaños de pantalla
  • Distribución a pantallas específicas

Si solo está orientado al nivel API> = 13, intente

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

A su salud

Sé que esto no es directamente una respuesta a su pregunta, pero otras respuestas aquí dan una buena idea de cómo identificar el tamaño de la pantalla. Usted escribió en su pregunta que tiene problemas con la inclinación y esto acaba de suceder a mí también.

Si ejecuta el giroscopio (o sensor de rotación) en un teléfono inteligente, los ejes x e y pueden definirse de forma diferente a una tableta, de acuerdo con la orientación predeterminada de ese dispositivo (por ejemplo, Samsung GS2 es el retrato por defecto, Samsung GT-7310 es Paisaje predeterminado, nuevo Google Nexus 7 es retrato por defecto, aunque es una tableta!).

Ahora, si desea utilizar giroscopio puede terminar con una solución de trabajo para teléfonos inteligentes, pero la confusión de eje en algunas tabletas o al revés.

Si utiliza una de las soluciones de arriba para ir sólo para el tamaño de la pantalla y luego aplicar

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

Para voltear el eje si tiene un tamaño de pantalla grande o xlarge esto podría funcionar en el 90% de los casos, pero por ejemplo en el Nexus 7 causará problemas (porque tiene orientación vertical por defecto y un tamaño de pantalla grande).

La forma más sencilla de arreglar esto se proporciona en RotationVectorSample que se incluye con las demostraciones de API al establecer la sceenOrientation a nosensor en su manifiesto:

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

Com.sec.feature.multiwindow.tablet en el gestor de paquetes es específico sólo para tablet y com.sec.feature.multiwindow.phone es específico para el teléfono.

Debajo del método se calcula la longitud diagonal de la pantalla del dispositivo para decidir que el dispositivo es un teléfono o una tableta. La única preocupación por este método es cuál es el valor umbral para decidir el tiempo que el dispositivo es tablet o no. En el ejemplo abajo lo establecí como 7 pulgadas y arriba.

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

Cada vez es más difícil trazar la línea entre el teléfono y la tableta. Por ejemplo (a partir de agosto de 2015) el Samsung Mega 6.3 dispositivo extrae recursos de las carpetas sw600dp – por lo que en lo que respecta a Android se trata de una tableta.

La respuesta de @Vyshnavi funciona en todos los dispositivos que hemos probado pero no para Mega 6.3.

@Helton Isac respuesta anterior devuelve el Mega 6.3 como un teléfono – pero ya que el dispositivo todavía agarra recursos de sw600dp puede causar otros problemas – por ejemplo, si utiliza un viewpager para los teléfonos y no para las tabletas que terminará con NPE errores .

Al final, parece que hay demasiadas condiciones para comprobar y sólo podemos tener que aceptar que algunos teléfonos son en realidad las tabletas: -P

Este es el método que uso:

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

Utilizando:

Configuración. SCREENLAYOUT_SIZE_MASK

Configuración. SCREENLAYOUT_SIZE_LARGE

¡Este es el método recomendado!

Por favor, consulte el siguiente código.

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

Creo que una tableta tiene un mínimo y máximo de 600 px de ancho y altura,
Así que necesita saber la densidad de la pantalla y la altura / anchura en dp,
Para recuperar el valor:

 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; 

Por ejemplo, tienen una diferencia importante (al menos para mi programa) entre el teléfono y la tableta. Es la orientación predeterminada del dispositivo. El teléfono tiene una orientación vertical, la tableta – paisaje. Y respectivamente el método para determinar el dispositivo:

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

EDITADO: Después de las discusiones con Dan Hulme cambió el nombre del método.

Me recomiendan la librería de la android 'cafeína' Eso es contener obtener teléfono o tableta, y 10inch ~!

Muy fácil de usar.

La biblioteca está aquí.

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

y use

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

Creo que esta es la forma más fácil de ser honesto. Esto verificará el tamaño de pantalla que se está utilizando:

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

¡La mejor de las suertes!

  • ¿Los eventos Javascript no funcionan en Tablet-pc?
  • @ Font-face problema de representación en la etiqueta de párrafo, Chrome Android 4
  • La aplicación no es compatible con la tableta
  • Cambiar el logotipo que aparece en Android ActionBar por programa
  • Diseño de aplicaciones de Android para tablets
  • Comenzando en el desarrollo de tablets Android
  • Archos 101 internet tablet: ¿Es posible ocultar los botones predeterminados de Android (software)
  • La aplicación de Android para tablets sigue mostrando "Designed for Phones"
  • Apk actualización para la tableta, todavía dice "Diseñado para teléfonos"
  • ¿Por qué mi aplicación no aparece en tablets en Google Play?
  • El menú de opciones de onCreate no se muestra en android 3.1
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.