programacion - cómo obtener el tamaño de la pantalla de Android programáticamente, de una vez por todas?

manual de programacion android pdf

Question

¿Cómo puedo saber el tamaño de mi pantalla mediante programación, en las unidades utilizadas por los eventos táctiles y Ver medición / diseño? En otras palabras, quiero las coordenadas de la esquina inferior derecha de la pantalla, en el sistema de coordenadas utilizado por los eventos táctiles '' getRawX()/getRawY() y View.getLocationOnScreen() .

No estoy seguro de llamar "píxeles" a las unidades de eventos / vistas deseadas, ya que evidentemente hay varias nociones de "píxeles" en mi teléfono en varios modos, y no se suman a una historia coherente.

Veo que se ha preguntado y respondido mucho sobre stackoverflow y en otros lugares, pero ninguna de las respuestas funciona en mi teléfono (droid 4, android 4.1.2) en todos los modos:

• ¿Puedo averiguar el ancho de la pantalla mediante programación en la aplicación de Android?
• ¿Cómo obtengo el ScreenSize programáticamente en Android?
• Android establece la visibilidad de visibilidad mediante programación en función del tamaño de la pantalla
• ¿Cómo obtengo el alto de la pantalla en Android?
• Obtener la altura de la pantalla en Android
• https://groups.google.com/forum/#!topic/android-developers/IpxnfvDFrpc
• http://shuklaxyz.blogspot.com/2012/02/how-to-programmatically-figure-out.html
• http://coderock.net/how-to-determine-screen-resolution-programmatically/
• http://www.codeproject.com/Tips/313848/Get-actual-screen-size-for-the-application-layout
• Android y configuración de ancho y alto mediante programación en unidades dp
• http://www.simplecodestuffs.com/how-to-get-screen-dimensions-programmatically-in-android/
• http://www.androidsnippets.com/get-size-and-orientation-of-the-screen
• http://grokbase.com/t/gg/android-developers/127aatfqb6/how-to-determine-screen-resolution-programmatically

(¡Guau!)

Esto es para el código de la biblioteca que necesita funcionar independientemente de si la aplicación está en "modo de compatibilidad de pantalla" (es decir, targetSdkVersion <= 10 en el manifiesto) o no, y tampoco quiero hacer ninguna suposición sobre la posición, el tamaño , o la existencia de la barra de estado o cualquier otra decoración de pantalla similar.

Aquí están los hechos:

1. mi teléfono (un androide 4 que ejecuta Android 4.1.2) tiene 540x960 píxeles físicos, es decir, puntos brillantes de colores pequeños.

2. el tamaño de la pantalla en las unidades deseadas, desde mirar eventos táctiles y Ver mediciones, es de 360x640 cuando la aplicación está en modo de compatibilidad de pantalla, 540x960 cuando la aplicación no está en modo de compatibilidad de pantalla. Estos son los números que necesito encontrar programáticamente, sin eliminar eventos táctiles o Vistas para encontrarlos, pero estoy teniendo una dificultad extrema para encontrar cualquier API que devuelva estos números.

3. Los objetos de Display y DisplayMetrics obtenidos de varias formas afirman que el tamaño de la pantalla es de 540x960 "píxeles" (ya sea en modo de compatibilidad de pantalla o no). Para ser específicos, todos los siguientes dicen 540x960 todo el tiempo: DisplayMetrics. {Width, height} Pixels, Display.getSize (), Display.getRealSize (), Display.get {Ancho, Altura} (),

4. Objetos de configuración obtenidos de varias formas, todos dicen pantalla {ancho, alto} Dp = 360x614 (ya sea en modo de compatibilidad de pantalla o no). No creo que eso represente toda la pantalla, ya que la relación de aspecto es incorrecta. (Creo que es toda la pantalla menos la barra de estado, necesito toda la pantalla). Creo que es seguro decir que toda la pantalla es de 360x640 dp, aunque no conozco ninguna API que devuelva ese 640.

5. DisplayMetrics obtenido de varias formas indica que la "densidad" es 1.0f cuando está en el modo de compatibilidad de pantalla, 1.5f cuando no está en el modo de compatibilidad de pantalla.

6. La getWindow().getAttributes().{width,height} no es útil, ya que normalmente contiene MATCH_PARENT lugar de tamaños reales. Pero al parecer, puedo obtener la respuesta deseada de getWindow().getDecorView().getMeasured{Width,Height}() de una actividad getWindow().getDecorView().getMeasured{Width,Height}() (que es realmente sorprendente ya que el decorView de la ventana de la actividad no parece ocupar toda la pantalla; parece que está ocupando la pantalla menos la barra de estado). Pero no quiero confiar en esto porque si la ventana cambia de tamaño (aparece un teclado virtual, alguien que llama a window.setAttributes ()? O tal vez no estoy en una actividad en absoluto), esto claramente va a ser todo incorrecto.

Entiendo que se supone que la siguiente fórmula es válida: píxeles = dp * densidad Parece estar de acuerdo con todos los números informados ((3), (4), (5) anteriores) cuando no está en modo de compatibilidad de pantalla: 540x960 = 360x640 * 1.5 Pero en el modo de compatibilidad de pantalla no se suma: 540x960! = 360x640 * 1 Entonces, algo está mal.

La explicación más simple, creo, es que los métodos enumerados en (3) arriba simplemente dan la respuesta incorrecta para "píxeles" cuando están en modo de compatibilidad de pantalla, es decir, estaban destinados a devolver 360x640 "píxeles" pero están equivocados regresando 540x960 en su lugar. Pero puede haber otras formas de verlo.

En cualquier caso, obtener los números deseados independientemente del modo, de las piezas de rompecabezas anteriores, es sin duda un rompecabezas complicado. Encontré una manera que parece funcionar en mi teléfono en ambos modos, pero es extremadamente indirecta, y se basa en dos suposiciones que todavía parecen bastante inestables (como se describe en los comentarios del código a continuación).

Aquí está mi receta:

/** get screen size in "pixels", i.e. touchevent/view units.
* on my droid 4, this is 360x640 or 540x960
* depending on whether the app is in screen compatibility mode
* (i.e. targetSdkVersion<=10 in the manifest) or not. */
public void getScreenSizePixels(int widthHeightInPixels[/*2*/])
{
    Resources resources = getResources();
    Configuration config = resources.getConfiguration();
    DisplayMetrics dm = resources.getDisplayMetrics();
    // Note, screenHeightDp isn''t reliable
    // (it seems to be too small by the height of the status bar),
    // but we assume screenWidthDp is reliable.
    // Note also, dm.widthPixels,dm.heightPixels aren''t reliably pixels
    // (they get confused when in screen compatibility mode, it seems),
    // but we assume their ratio is correct.
    double screenWidthInPixels = (double)config.screenWidthDp * dm.density;
    double screenHeightInPixels = screenWidthInPixels * dm.heightPixels / dm.widthPixels;
    widthHeightInPixels[0] = (int)(screenWidthInPixels + .5);
    widthHeightInPixels[1] = (int)(screenHeightInPixels + .5);
}

¿Hay alguna forma mejor / más limpia de encontrar el tamaño de la pantalla?

Answer 1

Al usar DisplayMetrics puede obtener la altura y el ancho de la pantalla de cualquier dispositivo. aquí está el código.

DisplayMetrics metrics; 
int width = 0, height = 0;

En tu método onCreate

 metrics = new DisplayMetrics();        
 getWindowManager().getDefaultDisplay().getMetrics(metrics);


 height = metrics.heightPixels;     
 width = metrics.widthPixels;

Prueba esto.

Answer 2

Creo que esta función te ayudará a obtener simplemente el ancho y la altura del tamaño de tu pantalla de Android. La función devuelve el ancho y alto como una matriz de enteros como se muestra a continuación

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

y en su método de creación de salida su ancho y altura como se muestra a continuación

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes /n/n  width = "+width+" /n Height = "+height);

Descargue el código fuente y pruébelo en su estudio de Android

Answer 3

Debería poner esto como un comentario, pero no tengo el representante para eso.
Puede que esta no sea una respuesta totalmente correcta, pero obtuve mis dimensiones cuando cambié el alto y el ancho en el método DisplayMetrics.

    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);   
    width = metrics.heightPixels;
    height = metrics.widthPixels;

como dije, esto puede no ser correcto, pero no sé por qué, pero funcionó para mí.

Answer 4

En su # 6, nota que DecorView parece proporcionar lo que desea, pero no cree que sea confiable. Creo que eso es lo más cercano que puedes venir. De acuerdo con la documentación de Window.getDecorView :

Recupere la vista de decoración de la ventana de nivel superior (que contiene el marco / las decoraciones de la ventana estándar y el contenido del cliente dentro de eso), que puede agregarse como una ventana al administrador de la ventana.

La barra de estado es parte de la decoración de ventana mencionada allí. Los teclados de software y otras superposiciones recibirán su propia ventana, por lo que no deberían interferir con los valores relevantes. Es correcto que no son precisamente las métricas de visualización, pero si su aplicación es de pantalla completa, siempre debe ser el tamaño de pantalla completa filtrada a través del traductor de compatibilidad. Otras aplicaciones no tendrán acceso a la Window su aplicación, por lo que no es necesario preocuparse de que otra aplicación cambie los atributos mientras no esté mirando.

Espero que ayude.

Answer 5

Si usa el nivel api 17 o superior, consulte getRealMetrics y getRealSize en la Display

Para el nivel api 14,15 y 16 mira here

Answer 6

Utilicé el teorema de Pitágoras para encontrar el tamaño diagonal de la pantalla del teléfono / tableta Android, el mismo principio se puede aplicar al iPhone o a la pantalla de Blackberry.

DisplayMetrics met = new DisplayMetrics();                
this.getWindowManager().getDefaultDisplay().getMetrics(met);// get display metrics object
String strSize = 
new DecimalFormat("##.##").format(Math.sqrt(((met.widthPixels / met.xdpi) *
(met.widthPixels / met.xdpi)) +
((met.heightPixels / met.ydpi) * (met.heightPixels / met.ydpi))));
// using Dots per inches with width and height

Pitágoras debe haber sido un genio, conocía la programación de teléfonos inteligentes hace muchos años: p

Answer 7

Utilizo el siguiente método para obtener el ancho del dispositivo:

public static int getDeviceWidth(Context context){
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    int width=display.getWidth();
    return width;
}

Answer 8

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Ahora puede medir el tamaño de su pantalla en píxeles, que es una mejor unidad de medida que un centímetro, ya que todos los botones, textviews, etc. se miden en esta unidad. Eso que uso normalmente