Tableta o teléfono - Android

140

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

Benny
fuente
26
Estás haciendo la pregunta equivocada. No importa si el dispositivo es un teléfono, tableta, televisor, tostadora, taza de té o termómetro. Lo que importa son las capacidades, no la clase de marketing definida por el dispositivo. Haga una nueva pregunta de Android que describa qué capacidades está buscando y cómo detectar si el dispositivo tiene tales capacidades, o cómo filtrarse del mercado para dispositivos que carecen de tales capacidades.
CommonsWare
77
@CommonsWare: algunas veces desea agregar funciones adicionales para dispositivos que tienen una pantalla más grande.
Bobs
10
@breceivemail: lo que significa que debe verificar si el dispositivo tiene una pantalla más grande. "Pantalla más grande"! = "Tableta".
CommonsWare
2
Puede encontrar una mejor respuesta aquí: stackoverflow.com/a/9308284/1750829 Simple como eso :-)
O Kazaz el
3
¡Me gustaría votar a favor de esta página entera! Un teléfono hace telefonía, una tableta no. Casi todas las sugerencias son trucos sucios que nadie debería usar. ¡El mundo sería un lugar mejor si nadie volviera a ver esta página!
Mark Gjøl

Respuestas:

122

Como se mencionó anteriormente, no desea verificar 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, por lo que desea utilizar diferentes archivos de diseño. Estos archivos se almacenan en los res/layout-<qualifiers>directorios. Puede crear un archivo XML en el directorio res/values-<same qualifiers>para cada uno de sus diseños y colocar un recurso int / bool / string en él para distinguir entre los diseños que utiliza.

Ejemplo:

Archivo res/values/screen.xml(suponiendo que res/layout/contenga sus archivos de diseño para teléfonos)

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


Archivo res/values-sw600dp/screen.xml(suponiendo que res/layout-sw600dp/contenga sus archivos de diseño para tabletas pequeñas 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(suponiendo que res/layout-sw720dp/contenga sus archivos de diseño para tabletas grandes como el Nexus 10):

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


Ahora se puede acceder al tipo de pantalla a través de la R.string.screen_typeconstante.

Juan
fuente
44
+1, excelente respuesta porque proporciona más información sobre por qué realmente quieres buscar una tableta / teléfono. Nos acercamos a un momento en el que los teléfonos se convertirán en pequeñas tabletas de todos modos;)
andr
¿Cómo se aplica esto a los teléfonos grandes, como el Galaxy Note y el nuevo Nexus 6? Al usar esta técnica, ¿se detectarán estos dispositivos grandes como teléfonos o tabletas?
PerracoLabs
1
Desafortunadamente, este enfoque no funciona para el dispositivo Samsung Mega 6.3 y lo devuelve como una tableta (sw600dp). ¿Alguna otra idea para capturar esto?
bkurzius
¿Las tabletas hacen llamadas telefónicas?
Mike
61

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

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

Los tamaños de pantalla LARGE y XLARGE son determinados por el fabricante en función de la distancia desde el ojo en el que se utilizarán (de ahí la idea de una tableta).

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

petey
fuente
En ambos, Kindle Fire y Motorola Droid Bionic, SCREENLAYOUT_SIZE_MASK == 15. Entonces, ¿por qué funcionaría su solución?
IgorGanapolsky
Creo que esto resulta cierto en el Kindle Fire. No tengo un biónico hoy ... pero lo comprobaré en unos días cuando mi amigo regrese a la ciudad. Sin embargo ... he estado probando la respuesta de Helton Isac y funciona de maravilla. Por favor revisa eso también.
Petey
44
Hay Configuration.SCREENLAYOUT_SIZE_XLARGE, por lo que no tiene que usar una constante, y puede usar >= LARGE.
Triang3l
2
Galaxy Note parece informar SCREENLAYOUT_SIZE_LARGE por lo que se clasificará erróneamente como tableta
miguelSantirso
1
Si la fuente del dispositivo es pequeña y el tamaño de la pantalla es pequeño en la configuración, este caso se devuelve verdadero.
arul
38

Esta publicación me ayudó mucho,

Lamentablemente, 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 podría implementar la lógica de la pantalla. Y en mi análisis, la tableta debe tener más de 7 pulgadas (Xlarge) a partir de MDPI.

Aquí está el código a continuación, que se creó en base a 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;
}
Helton Isac
fuente
2
La mejor solución que encontré, ¡gracias Helton Isac! ¿Quizás pueda agregar (para una mejor solución) un cheque para las pulgadas de la pantalla? de todos modos, un 10 para esta solución
Aracem
77
Realmente no estoy de acuerdo. Este es un método para encontrar un determinado tamaño de pantalla. Nuevamente, como he respondido, NO HAY diferencia entre una tableta y un teléfono. Esta no es una respuesta a la pregunta. No es posible diferenciar porque no hay 1 diferencia. Si necesita codificar ciertas funciones (como parece hacer para ciertos tamaños de pantalla), hágalo, pero no lo llame tableta o teléfono. El tema de inicio parecía poner la línea @ cierta funcionalidad de inclinación. Lea el comentario de @commonware sobre la pregunta de forma exhaustiva.
Nanne
1
Estoy de acuerdo con Nanne, pero como dije, en mi aplicación necesito mostrar dos paneles si la pantalla es lo suficientemente grande como para hacerlo. Y no puedo usar diseños en este caso, porque la lógica de la pantalla estaba en el lado de Java.
Helton Isac
3
Helton, gracias por esto. Pensé que diría que esto devuelve: Kindle Fire: falso, Moto Xoom (v1): verdadero, Galaxy Nota: falso, Galaxy Tab 10.1 limitado: verdadero
petey
Aparte del argumento, Configuration.SCREENLAYOUT_SIZE_XLARGE = 4 de acuerdo con developer.android.com/reference/android/content/res/… que se puede usar en su lugar para un nivel de API inferior a 9.
trgraglia
12

¿Por qué no calcular el tamaño de la diagonal de la pantalla y usarlo 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 de 9 pulgadas o menos.

Volker Voecking
fuente
Esto no está funcionando ... simplemente algunos teléfonos informan los valores de densidad incorrectos y el cálculo en pulgadas falla - vea allí: stackoverflow.com/questions/2193457/…
STeN
Bueno, me gustan las tabletas de 7 '(tamaño de bolsillo) y esta respuesta es la mejor, creo. Pero return (screenDiagonal> = 9.0); debería ser return (screenDiagonal> = 6.5). Sin embargo, depende del uso como se comenta en los comentarios a la pregunta.
Jan Bergström
11

no hay diferencia. Debes definir cuál crees que es la diferencia, y verificar eso. ¿Una pestaña de galaxia es un teléfono? o una tableta? ¿y por qué?

Debe definir qué características específicas está buscando y codificar para eso.

Parece que estás buscando 'inclinación'. Creo que esto es lo mismo que el acelerómetro (¿es una palabra?). Puede verificar 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)

Nanne
fuente
Tengo problemas con mi función de inclinación y mi nueva tableta (Transformador)
Benny
Una especie de respuesta tonta, por supuesto, hay una diferencia. Galaxy = teléfono. ¿Por qué? Porque es un "teléfono inteligente" según el fabricante para uno. Si estás insinuando que necesita verificar el tamaño, la capacidad de llamar o ... cualquier cosa, solo dilo.
Dave
3
No estoy de acuerdo, puede que no funcione para todos los móviles, mientras que algunas tabletas tienen estos sensores. Es por eso que mi respuesta inicial sobre no hay diferencia. De todos modos, agregué un código que deberías probar.
Nanne
2
El problema es que debido a que las tabletas se "compilan" en modo horizontal, los ejes xey del acelerómetro se voltean cuando espera que su aplicación se ejecute en modo vertical. Esto puede estropear un poco las cosas :) Por lo tanto, es vital que compruebe el clima que está ejecutando en una tableta o no.
pumpkee 01 de
1
Pero entonces es al revés => si eso es lo único que hace que un dispositivo sea una tableta, debe averiguar cómo funciona el eje x / y, no al revés. ¿Dudo por cierto que esto sea cierto para todas las tabletas y / o teléfonos?
Nanne
10

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 es a continuación. Si desea saber algo basado en sensores, tamaño de pantalla, etc., esta es realmente una pregunta diferente.

Además, mientras usaba la resolución de pantalla, o la gestión de recursos grande frente a xlarge, puede haber sido un enfoque válido en el pasado, los nuevos dispositivos 'móviles' ahora vienen con pantallas tan grandes y altas resoluciones que están borrando esta línea, si realmente lo desean para conocer la capacidad de llamadas telefónicas versus ninguna llamada telefónica, lo siguiente es "mejor".

TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){
    return "Tablet";
}else{
    return "Mobile";
}
Robert Dale Johnson III
fuente
9
Algunas tabletas pueden telefonear y tener un tipo GSM o CDMA ... Por lo tanto, su solución tampoco es perfecta.
arnouf
6

Basado en Robert Dale Johnson III y Helton Isac se me ocurrió 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;
}

Entonces, en su código, haga un filtro como

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

En el código fuente de la aplicación Google IOSched 2017 , se utiliza el siguiente método:

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

Para aquellos que desean consultar el código de Google para decidir qué dispositivos usarán una interfaz de usuario de tableta, pueden 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;
        }
        }
Pier Betos
fuente
2
¿Cuál es el valor de shortSize?
kc ochibili
3

Este método es recomendado por Google. Veo este código en la aplicación de Android oficial de Googleiosched

public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}
hqt
fuente
¡Esta solución, por ejemplo, no funciona en un emulador con API 18 y Nexus 7 1200 x 1920 xhdpi!
Ingo
1
deberías probar en un dispositivo real :)
hqt
He probado en Emulator y el resultado de "isTablet (Context context) fue falso. Inténtalo por tu cuenta en Emulator.
Ingo
1
Gracias por este @hqt, acabo de transcodificar esto al C # necesario para Xamarin Studio:public static bool isTablet (Context context) { return (context.Resources.Configuration.ScreenLayout & Android.Content.Res.ScreenLayout.SizeMask) >= Android.Content.Res.ScreenLayout.SizeLarge; }
Phil Ryan
2

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 , esa no es la forma recomendada para admitir varios tamaños de pantalla.

En cambio, declare diferentes recursos para tabletas o teléfonos. Esto se hace añadiendo mis carpetas de recursos adicionales para layout, values, etc.

  • Para Android 3.2 (API nivel 13), agregue una sw600dpcarpeta. Esto significa que el S mallest w idth es al menos 600dp, que es aproximadamente la brecha teléfono / comprimido. Sin embargo, también puede agregar otros tamaños. Consulte esta respuesta para ver un ejemplo de cómo agregar un archivo de recursos de diseño adicional.

  • Si también es compatible con dispositivos anteriores a Android 3.2, deberá agregar carpetas largeo xlargecarpetas para admitir tabletas. (Los teléfonos son generalmente smally normal.)

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

ingrese la descripción de la imagen aquí

Al usar este método, el sistema determina todo por usted. No tiene que preocuparse por qué dispositivo se está utilizando en tiempo de ejecución. Solo debe proporcionar los recursos adecuados y dejar que Android haga todo el trabajo.

Notas

  • Puede usar alias para evitar duplicar archivos de recursos idénticos.

Documentos de Android que vale la pena leer

Suragch
fuente
2

Si solo se dirige al nivel de API> = 13, intente

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

salud :-)

Mohanraj Balasubramaniam
fuente
1

Pensando en los "nuevos" directorios aceptados (valores-sw600dp por ejemplo) creé este método basado en el ancho DP de la pantalla:

 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 = Ancho dp
Hdp = Altura dp

Aracem
fuente
1

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

Usado así:

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

Realmente no quiero ver el tamaño de los píxeles, sino que solo confío en el tamaño de la pantalla.

Funciona bien, ya que Nexus 7 (GRANDE) se detecta como tableta, pero no Galaxy S3 (NORMAL).

Max
fuente
1

Use este método que devuelve verdadero cuando el dispositivo es una tableta

public boolean isTablet(Context context) {  
    return (context.getResources().getConfiguration().screenLayout   
        & Configuration.SCREENLAYOUT_SIZE_MASK)    
        >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}
Vyshnavi
fuente
¡Esta solución, por ejemplo, no funciona en un emulador con API 18 y Nexus 7 1200 x 1920 xhdpi!
Ingo
Esto ya no funciona en algunos dispositivos. Por ejemplo, devuelve falso para el dispositivo Samsung Mega
bkurzius
Sí. Esto ya no funciona ... De hecho, solía agregar booleano en todos los archivos de cadena para los valores de cada carpeta, values_large, etc. <bool name = "isTablet"> false </bool> <bool name = "isLargeTablet"> false </bool> y luego verifique si R.bool.isTablet es verdadero para determinar si el dispositivo es una tableta
Vyshnavi
1

Si la detección del tamaño de la pantalla no devuelve el valor correcto en los dispositivos más nuevos, 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 (perdón por mi inglés)

BSTech
fuente
0

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 tenía problemas con la inclinación y esto también me sucedió a mí.

Si ejecuta el giroscopio (o sensor de rotación) en un teléfono inteligente, los ejes X e Y pueden definirse de manera diferente que en una tableta, de acuerdo con la orientación predeterminada de ese dispositivo (por ejemplo, Samsung GS2 es vertical, Samsung GT-7310 es paisaje predeterminado, el nuevo Google Nexus 7 es el retrato predeterminado, ¡aunque es una tableta!).

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

Si usa una de las soluciones de arriba para ir solo al 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 grande, esto podría funcionar en el 90% de los casos, pero, por ejemplo, en el Nexus 7 causará problemas (porque tiene una orientación vertical predeterminada y un tamaño de pantalla grande).

La forma más sencilla de solucionar esto se proporciona en RotationVectorSample que se incluye con las demostraciones de API configurando sceenOrientation nosensoren su manifiesto:

<activity
    ...
    android:screenOrientation="nosensor">
...
</activity>
Alexander Pacha
fuente
0

com.sec.feature.multiwindow.tablet en el administrador de paquetes es específico solo para la tableta y com.sec.feature.multiwindow.phone es específico para el teléfono.

RBz
fuente
0

El siguiente método es calcular la longitud diagonal de la pantalla del dispositivo para decidir si el dispositivo es un teléfono o una tableta. La única preocupación para este método es cuál es el valor umbral para decidir si el dispositivo es tableta o no. en el ejemplo a continuación lo configuré como 7 pulgadas o más.

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 );
}
MinFu
fuente
0
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)));
    }
Zar E Ahmer
fuente
0

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 dispositivo Samsung Mega 6.3 extrae recursos de las carpetas sw600dp, por lo que, en lo que respecta a Android, es una tableta.

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

La respuesta anterior de @Helton Isac devuelve el Mega 6.3 como teléfono, pero dado que el dispositivo todavía toma recursos de sw600dp, puede causar otros problemas, por ejemplo, si usa un visor para teléfonos y no para tabletas, terminará con errores de NPE .

Al final, parece que hay demasiadas condiciones para verificar y es posible que tengamos que aceptar que algunos teléfonos son en realidad tabletas :-P

bkurzius
fuente
0

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!

Jorgesys
fuente
Explicación para -1? , este es un método recomendado por google.
Jorgesys
0

¿Por qué usar esto?

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

Veo muchas formas arriba. La clase de configuración tiene la respuesta correcta a continuación:

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

solo llama :

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

¿está bien?

Longalei
fuente
0

Necesitaba detectar el teléfono inteligente / tableta solo en el archivo de diseño, porque estoy usando el código de navegación.

Lo primero que hice fue crear un directorio layout-sw600dp pero no funcionaba bien porque se activaría en mi Nokia 8 en modo horizontal, pero la altura de la pantalla sería demasiado pequeña.

Entonces, cambié el nombre del directorio como layout-sw600dp-h400dp y luego obtuve el efecto deseado. El parámetro h-xxxdp debe depender de la cantidad de contenido que desee colocar en su diseño y, como tal, debe depender de la aplicación.

Dominique Lorre
fuente
-1

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;
}
SathishBabu S
fuente
1
Ya no es válido con ICS. De hecho, hay tabletas con versiones de Android inferiores a 11
mdelolmo
1
Esto NO es confiable. Los nuevos teléfonos ICS tienen un nivel API> 11.
Jason Robinson
-1

Creo que una tableta tiene un ancho y una altura mínima y máxima de 600 px,
así que necesito saber la densidad de la pantalla y la altura / ancho 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;

usuario1503892
fuente
Esto no está bien porque Samsung galaxy s3 resultó 720 x 1280.
Nikhil
-1

Por ejemplo, tengo 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 - horizontal. Y respectivamente 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.

Plata
fuente
1
No todas las tabletas tienen una orientación horizontal predeterminada. Y si la orientación "predeterminada" es importante para su programa, probablemente sea incorrecta en otros aspectos. Vea esta publicación del Blog de desarrolladores de Android para ver un ejemplo.
Dan Hulme
Por favor, ¿puede dar ejemplos específicos de tabletas, que en la orientación predeterminada el ancho es menor que la altura? Y, por supuesto, sabes mejor cuál debería ser mi aplicación: D.
Plata
El Nexus 7 sería un ejemplo. Pero no tiene que aceptar mi palabra: lea el artículo que vinculé, que lo explica todo.
Dan Hulme
Creo que debería cambiar el nombre de mi método. De hecho, lo más importante (al menos para mi aplicación;)) es la orientación predeterminada del dispositivo, y mi método es adecuado para esta tarea. También identificó muy correctamente el problema @Nanne respuesta, ver arriba.
Plata
-1

Para mí, la distinción entre teléfono y tableta no es el tamaño del dispositivo y / o la densidad de píxeles, que cambiará con la tecnología y el gusto, sino la relación de pantalla. Si estoy mostrando una pantalla de texto, necesito saber si, por ejemplo, se necesitan 15 líneas largas (teléfono) frente a 20 líneas más cortas (tableta). Para mi juego utilizo lo siguiente para una estimación aproximada del rectángulo con el que tratará mi software:

    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;
    }
Androidcoder
fuente
-3

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!

Otroberts
fuente