android - telefono - ¿Determinar si el dispositivo es un teléfono inteligente o tableta?

telefono inteligente

Question

Esta pregunta ya tiene una respuesta aquí:

• Tableta o teléfono - Android 28 respuestas

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 en función del 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 funciona para mí 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)
}

Answer 1

Considero que una tableta tiene al menos una pantalla de 6,5 pulgadas. Esta es la forma de calcularlo, según 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
}

Answer 2

Dado que las tabletas son en general más grandes que los teléfonos inteligentes y que una tableta de baja resolución puede tener la misma cantidad de píxeles que un teléfono inteligente de alta resolución, una forma de resolverlo 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 
    }

Answer 3

Este tema se discute en el entrenamiento de Android:

Usa el calificador de ancho más pequeño

Si lees todo el tema, explican cómo establecer un valor booleano en un archivo de valor específico (como res / values-sw600dp / attr.xml):

<resources>
    <bool name="isTablet">true</bool>
</resources>

Debido a que el calificador sw600dp solo es válido para plataformas por encima de Android 3.2. Si desea asegurarse de que esta técnica funcione en todas las plataformas (antes de la versión 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 ​​/), establece 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
}

Answer 4

La mejor opción que encontré y la menos intrusiva es establecer una etiqueta param en su xml, como

DISEÑO DE TELÉFONO XML

<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"/>

TABLET XML LAYOUT

<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 ti.

Answer 5

La solución que utilizo es definir dos diseños. Una con la carpeta de diseño configurada para, por ejemplo, layout-sw600dp. Lo uso para proporcionar un botón de menú para los usuarios de mi tableta y para ocultarlo a los usuarios del teléfono. De esa manera no tengo (todavía) que implementar la barra de acción para mis aplicaciones existentes ...

Vea esta publicación para más detalles .

Answer 6

Me gusta la solución de Ol_v_er y su simplicidad, sin embargo, he descubierto que no siempre es tan simple, lo que con los nuevos dispositivos y pantallas aparece 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é here por John usa un recurso String, en lugar de un booleano, para especificar el tamaño de la tableta. Entonces, en lugar de simplemente poner verdadero en un archivo /res/values-sw600dp/screen.xml (asumiendo que aquí es donde están los diseños para tabletas pequeñas) pondría:

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

Consíguelo de la siguiente manera y luego haga lo que necesita 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 la tableta de detección de 7 y 10 pulgadas programáticamente también fue lo que estaba buscando. Es posible que desee verificarlo si las respuestas aquí no le permiten ser tan específicas como le gustaría. Él hace un gran trabajo explicando cómo calcular diferentes métricas para descubrir con qué estás lidiando.

ACTUALIZAR

Al observar 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é que lo agregaría. Lo anterior le da un poco más de "control" sobre él, pero si solo quiere 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;
}

Answer 7

Re: la tangente anterior sobre cómo decirle a un teléfono que no es teléfono: por lo que sé, solo un teléfono tiene un IMEI (Identidad Internacional de Equipos de Estación Móvil) 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.");
    }

Descubrí que en un emulador de Nook, getPhoneType () devuelve un tipo de teléfono de "GSM" por alguna razón, por lo que parece que la verificación del tipo de teléfono no es confiable. Del mismo modo, getNetworkType () devolverá 0 para un teléfono en modo avión. De hecho, el modo avión causará que los métodos getLine1Number () y getSim * también devuelvan un valor nulo. Pero incluso en modo avión, el IMEI de un teléfono persiste.

Answer 8

Supongo 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., entonces esta es una pregunta realmente diferente.

Además, mientras se usa 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 difuminando esta línea mientras que si realmente lo desea para conocer la capacidad de llamada telefónica y no llamada, lo siguiente es "lo mejor".

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

Answer 9

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