¿Cómo determinar la categoría de tamaño de pantalla del dispositivo (pequeño, normal, grande, xlarge) usando el código?

308

¿Hay alguna forma de determinar la categoría del tamaño de pantalla del dispositivo actual, como pequeño, normal, grande, xlarge?

No la densidad, sino el tamaño de la pantalla.

android screen android-screen-support vieux
fuente

Respuestas:

420

Puedes usar la Configuration.screenLayoutmáscara de bits.

Ejemplo:

if ((getResources().getConfiguration().screenLayout & 
    Configuration.SCREENLAYOUT_SIZE_MASK) == 
        Configuration.SCREENLAYOUT_SIZE_LARGE) {
    // on a large screen device ...

}
Jeff Gilfelt
fuente
31
Para obtener una detección x-large, asegúrese de usar el objetivo android-3.0 en su proyecto. O use el valor estático 4 para x-large.
Peterdk
55
Algunos dispositivos pueden tener un tamaño INDEFINIDO de la pantalla, por lo que puede ser útil también consulte con Configuración. SCREENLAYOUT_SIZE_UNDEFINED.
valerybodak
¿Podría usar> = para obtener pantallas más grandes o más grandes?
Andrew S
150

El siguiente código desarrolla la respuesta anterior, mostrando el tamaño de la pantalla como un Brindis.

//Determine screen size
if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
    Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
    Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
    Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Screen size is neither large, normal or small", Toast.LENGTH_LONG).show();
}

El siguiente código muestra la densidad de la pantalla como un brindis.

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density == DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
Mel
fuente
El brindis es bueno para deving.
MinceMan
alguien puede confirmar extra grande?
Nathan H
68

La respuesta de Jeff Gilfelt como método auxiliar estático:

private static String getSizeName(Context context) {
    int screenLayout = context.getResources().getConfiguration().screenLayout;
    screenLayout &= Configuration.SCREENLAYOUT_SIZE_MASK;

    switch (screenLayout) {
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        return "small";
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        return "normal";
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        return "large";
    case 4: // Configuration.SCREENLAYOUT_SIZE_XLARGE is API >= 9
        return "xlarge";
    default:
        return "undefined";
    }
}
qwertzguy
fuente
12 
private String getDeviceDensity() {
    int density = mContext.getResources().getDisplayMetrics().densityDpi;
    switch (density)
    {
        case DisplayMetrics.DENSITY_MEDIUM:
            return "MDPI";
        case DisplayMetrics.DENSITY_HIGH:
            return "HDPI";
        case DisplayMetrics.DENSITY_LOW:
            return "LDPI";
        case DisplayMetrics.DENSITY_XHIGH:
            return "XHDPI";
        case DisplayMetrics.DENSITY_TV:
            return "TV";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "XXHDPI";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "XXXHDPI";
        default:
            return "Unknown";
    }
}
Pawan Maheshwari
fuente
1
Esto obtiene la densidad de la pantalla. La pregunta especifica "No es la densidad, sino el tamaño de la pantalla".
Subaru Tashiro
11

Gracias por las respuestas anteriores, eso me ayudó mucho :-) Pero para aquellos (como yo) obligados a seguir soportando Android 1.5, podemos usar la reflexión de Java para compatibilidad con versiones anteriores:

Configuration conf = getResources().getConfiguration();
int screenLayout = 1; // application default behavior
try {
    Field field = conf.getClass().getDeclaredField("screenLayout");
    screenLayout = field.getInt(conf);
} catch (Exception e) {
    // NoSuchFieldException or related stuff
}
// Configuration.SCREENLAYOUT_SIZE_MASK == 15
int screenType = screenLayout & 15;
// Configuration.SCREENLAYOUT_SIZE_SMALL == 1
// Configuration.SCREENLAYOUT_SIZE_NORMAL == 2
// Configuration.SCREENLAYOUT_SIZE_LARGE == 3
// Configuration.SCREENLAYOUT_SIZE_XLARGE == 4
if (screenType == 1) {
    ...
} else if (screenType == 2) {
    ...
} else if (screenType == 3) {
    ...
} else if (screenType == 4) {
    ...
} else { // undefined
    ...
}
A. Masson
fuente
2
Puede apuntar a la última versión de la plataforma y hacer referencia a las constantes de la Configurationclase. Estos son valores finales estáticos que se incluirán en línea en el momento de la compilación (es decir, se reemplazarán por sus valores reales), por lo que su código no se romperá en versiones anteriores de la plataforma.
Karakuri
Bien, no lo sabía ... ¿Estás hablando de android: targetSdkVersion?
A. Masson
1
Sí, así es como apuntarías a una versión en particular. La mayoría de las personas (al menos eso he visto) configuran su targetSdkVersionversión más reciente.
Karakuri
9

Si desea conocer fácilmente la densidad y el tamaño de la pantalla de un dispositivo Android, puede usar esta aplicación gratuita (no se requiere permiso): https://market.android.com/details?id=com.jotabout.screeninfo

mmathieum
fuente
3
Esta pregunta no se trata de un dispositivo específico, sino de la programación para múltiples perfiles de división (que es un proceso importante de desarrollo de software cuando se desarrolla para plataformas móviles).
mtmurdock
1
buena aplicación para saber está disponible en el mercado, también sería bueno ver el código que usa la aplicación para obtener su información
Stan Kurdziel
44
@StanKurdziel El código fuente se publica bajo la licencia de código abierto del MIT y está disponible en: github.com/mportuesisf/ScreenInfo
mmathieum
Este enlace está muerto ahora
Vadim Kotov
5

¿Necesita verificar si hay pantallas de gran tamaño y x..altas densidades? Este es el código alterado de la respuesta elegida.

//Determine screen size
if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {     
    Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {     
    Toast.makeText(this, "Normal sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {     
    Toast.makeText(this, "Small sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {     
    Toast.makeText(this, "XLarge sized screen" , Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();
}

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density==DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XHIGH) {
    Toast.makeText(this, "DENSITY_XHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXHIGH) {
    Toast.makeText(this, "DENSITY_XXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXXHIGH) {
    Toast.makeText(this, "DENSITY_XXXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
}
Tom McFarlin
fuente
[Densidad] En este caso necesitas estar en actividad. Si está fuera, use getWindowManager () este código WindowManager windowManager = (WindowManager) context .getSystemService (Context.WINDOW_SERVICE);
horkavlna
3

Aquí hay una versión de Xamarin para Android de la respuesta de Tom McFarlin 

        //Determine screen size
        if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeLarge) {
            Toast.MakeText (this, "Large screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeNormal) {
            Toast.MakeText (this, "Normal screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeSmall) {
            Toast.MakeText (this, "Small screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeXlarge) {
            Toast.MakeText (this, "XLarge screen", ToastLength.Short).Show ();
        } else {
            Toast.MakeText (this, "Screen size is neither large, normal or small", ToastLength.Short).Show ();
        }
        //Determine density
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager.DefaultDisplay.GetMetrics (metrics);
        var density = metrics.DensityDpi;
        if (density == DisplayMetricsDensity.High) {
            Toast.MakeText (this, "DENSITY_HIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Medium) {
            Toast.MakeText (this, "DENSITY_MEDIUM... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Low) {
            Toast.MakeText (this, "DENSITY_LOW... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xhigh) {
            Toast.MakeText (this, "DENSITY_XHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxhigh) {
            Toast.MakeText (this, "DENSITY_XXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxxhigh) {
            Toast.MakeText (this, "DENSITY_XXXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else {
            Toast.MakeText (this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + density, ToastLength.Long).Show ();
        }
ellechino
fuente
2
Por favor, no solo descargue algo de código, sino que explique lo que ha hecho y cómo esto ayuda
David Medenjak
2

Pruebe esta función isLayoutSizeAtLeast (int screenSize)

Para verificar pantallas pequeñas, al menos 320x426 dp y superiores getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_SMALL);

Para verificar la pantalla normal, al menos 320x470 dp y superior getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_NORMAL);

Para comprobar la pantalla grande, al menos 480x640 dp y superiores getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_LARGE);

Para comprobar la pantalla extra grande, al menos 720x960 dp y superior getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_XLARGE);

Devendra Vaja
fuente
¡Agradable! ¡Ese método también está disponible desde el nivel 11 de API!
Enselic
2

En 2018, si necesita la respuesta de Jeff en Kotlin, aquí está:

  private fun determineScreenSize(): String {
    // Thanks to https://stackoverflow.com/a/5016350/2563009.
    val screenLayout = resources.configuration.screenLayout
    return when {
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_XLARGE -> "Xlarge"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_UNDEFINED -> "Undefined"
      else -> error("Unknown screenLayout: $screenLayout")
    }
  }
Thuy Trinh
fuente
1

¿No podrías hacer esto usando un recurso de cadena y enumeraciones? Puede definir un recurso de cadena que tenga el nombre del tamaño de pantalla, como PEQUEÑO, MEDIO o GRANDE. Luego, podría usar el valor del recurso de cadena para crear una instancia de la enumeración.

  1. Defina una enumeración en su código para los diferentes tamaños de pantalla que le interesan. 

    public Enum ScreenSize {
    SMALL,
    MEDIUM,
    LARGE,;
}

  2. Defina un recurso de cadena, digamos screenize, cuyo valor será PEQUEÑO, MEDIO o GRANDE. 

    <string name="screensize">MEDIUM</string>
  3. Coloque una copia de screensizeun recurso de cadena en cada dimensión que le interese.
    Por ejemplo, <string name="screensize">MEDIUM</string>iría en values-sw600dp / strings.xml y values-medium / strings.xml y <string name="screensize">LARGE</string>entraría en sw720dp / strings.xml y values-large / strings.xml.
  4. En código, escribe
    ScreenSize size = ScreenSize.valueOf(getReources().getString(R.string.screensize);
Prof Mo
fuente
Esto fue prometedor ... Sin embargo, lo he probado con 3 dispositivos y la tableta sigue devolviendo PEQUEÑA cuando espero GRANDE. Mis archivos string.xml se definen dentro de values-h1024dp, values-h700dp y values-h200dp con los correspondientes <string name = "Screensize"> xxxxxx </string>
A. Masson
1

Copie y pegue este código en su Activityy cuando se ejecute, aparecerá Toastla categoría de tamaño de pantalla del dispositivo.

int screenSize = getResources().getConfiguration().screenLayout &
        Configuration.SCREENLAYOUT_SIZE_MASK;

String toastMsg;
switch(screenSize) {
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        toastMsg = "Large screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        toastMsg = "Normal screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        toastMsg = "Small screen";
        break;
    default:
        toastMsg = "Screen size is neither large, normal or small";
}
Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();
Alireza Ghanbarinia
fuente