Cómo obtener las dimensiones de la pantalla como píxeles en Android

Creé algunos elementos personalizados y quiero colocarlos programáticamente en la esquina superior derecha (n píxeles desde el borde superior y m píxeles desde el borde derecho). Por lo tanto, necesito obtener el ancho y la altura de la pantalla y luego establecer la posición:

int px = screenWidth - m;
int py = screenHeight - n;

Como lo consigo screenWidth y screenHeight en la actividad principal?

preguntado el 19 de junio de 09 a las 05:06

Usa dp en lugar de px. porque distorsionará su diseño con otros dispositivos .. -

No olvide multiplicar por getResources (). GetDisplayMetrics (). Densidad para tener en cuenta la escala de visualización -

Esto demuestra que la respuesta más votada no siempre es la mejor (y muchas personas repiten las respuestas para el representante). En lugar del combo getSize y getWidth / getHeight obsoleto (ignorando los errores), pruebe Balaji.K's getMetrics. El comentario de Nik en su respuesta incluso explica getDisplayMetrics para considerar el tamaño de la barra de estado / sistema. También puedes usar densidad como explicaron jmaculate y LoungeKatt para tener el EXACT valor:DisplayMetrics dm = getResources().getDisplayMetrics(); float fwidth = dm.density * dm.widthPixels; Probado en Android v2.2 (API 8) y v4.0 con buenos resultados y sin errores / advertencias. -

DisplayMetrics displaymetrics = new DisplayMetrics (); getWindowManager (). getDefaultDisplay (). getMetrics (displaymetrics); int altura = displaymetrics.heightPixels; int ancho = displaymetrics.widthPixels; -

otra forma de obtener DisplayMetrics: Resources.getSystem().getDisplayMetrics(). No necesitarás un Context para conseguirlos. -

30 Respuestas

Si desea las dimensiones de la pantalla en píxeles, puede usar getSize:

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

Si no estás en un Activity puedes obtener el predeterminado Display vía WINDOW_SERVICE:

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Si está en un fragmento y desea lograr esto, simplemente use Activity.WindowManager (en Xamarin.Android) o getActivity (). GetWindowManager () (en java).

Antes getSize se introdujo (en el nivel de API 13), puede utilizar el getWidth y getHeight métodos que ahora están en desuso:

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

Sin embargo, para el caso de uso que está describiendo, un margen / relleno en el diseño parece más apropiado.

Otra forma es: Métricas de visualización

Una estructura que describe información general sobre una pantalla, como su tamaño, densidad y escala de fuente. Para acceder a los miembros de DisplayMetrics, inicialice un objeto como este:

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

Podemos utilizar widthPixels para obtener información para:

"El ancho absoluto de la pantalla en píxeles".

Ejemplo:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

Actualización de api nivel 30

final WindowMetrics metrics = windowManager.getCurrentWindowMetrics();
 // Gets all excluding insets
 final WindowInsets windowInsets = metrics.getWindowInsets();
 Insets insets = windowInsets.getInsetsIgnoreVisibility(WindowInsets.Type.navigationBars()
         | WindowInsets.Type.displayCutout());

 int insetsWidth = insets.right + insets.left;
 int insetsHeight = insets.top + insets.bottom;

 // Legacy size that Display#getSize reports
 final Rect bounds = metrics.getBounds();
 final Size legacySize = new Size(bounds.width() - insetsWidth,
         bounds.height() - insetsHeight);

respondido 23 nov., 20:16

getWidth () o getSize ()? ¿Qué usaría si necesito que mi aplicación se ejecute en API <13 así como en API> 13? - Carol

intente {display.getSize (tamaño); ancho = tamaño.x; altura = talla. y; } catch (NoSuchMethodError e) {ancho = display.getWidth (); altura = display.getHeight (); } - Arnaud

No veo por qué quieres usar try/catch para tal cheque? ¿Por qué no usar simplemente if (android.os.Build.VERSION.SDK_INT >= 13) sin ninguna excepción lanzada en absoluto? pienso try/catch en un flujo de aplicaciones normal como una mala práctica. - Patrik

@ A-Live, la aplicación también se rompería (pero no se bloqueará). Sin embargo, los desarrolladores debemos verificar previamente una nueva versión del sistema operativo y esto tal vez solo oculte un problema. También con este argumento uno podría / debería rodear cada pocas líneas de código con try / catch, que en mi opinión es una mala práctica como ya se mencionó. - Patrik

¿Qué sucede si desea obtener el tamaño de la pantalla excluyendo la barra de navegación y / o la barra de notificaciones? desarrollador de Android

Una forma es:

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

Está en desuso y debería probar el siguiente código en su lugar. Las dos primeras líneas de código le dan la DisplayMetrics objecs. Este objeto contiene los campos como heightPixels, widthPixels.

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

Actualización de api nivel 30

final WindowMetrics metrics = windowManager.getCurrentWindowMetrics();
 // Gets all excluding insets
 final WindowInsets windowInsets = metrics.getWindowInsets();
 Insets insets = windowInsets.getInsetsIgnoreVisibility(WindowInsets.Type.navigationBars()
         | WindowInsets.Type.displayCutout());

 int insetsWidth = insets.right + insets.left;
 int insetsHeight = insets.top + insets.bottom;

 // Legacy size that Display#getSize reports
 final Rect bounds = metrics.getBounds();
 final Size legacySize = new Size(bounds.width() - insetsWidth,
         bounds.height() - insetsHeight);

respondido 23 nov., 20:16

Tenga en cuenta que las métricas (ancho, alto) cambian según la rotación del dispositivo. - Tony Chan

Las métricas devolverán el tamaño de la pantalla, pero HoneyComb y más, su actividad tendrá menos espacio que el devuelto debido a la barra del sistema. - Chico

@ Guy, depende de tu implementación. Puede ocultar la barra de estado: requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); - Hagai L

También existe de esta manera: getContext (). GetResources (). GetDisplayMetrics (). WidthPixels - nik

escala flotante final = getResources (). getDisplayMetrics (). densidad; int ancho = (int) (metrics.widthPixels * scale + 0.5f); - Debe tener en cuenta la densidad del dispositivo al hacerlo de esa manera. - abandonado la Cesta

Puede que no responda a su pregunta, pero podría ser útil saber (yo mismo lo estaba buscando cuando llegué a esta pregunta) que si necesita una dimensión de Vista, pero su código se está ejecutando cuando su diseño aún no se ha diseñado (por ejemplo en onCreate() ) puede configurar un ViewTreeObserver.OnGlobalLayoutListener con View.getViewTreeObserver().addOnGlobalLayoutListener() y coloque allí el código relevante que necesita la dimensión de la vista. Se llamará a la devolución de llamada del oyente cuando se haya establecido el diseño.

Respondido 06 Abr '11, 22:04

o simplemente escriba view.post - lukas hanacek

Sin embargo, no se garantiza que view.post funcione. Es solo una solución. - Marsbear

@marsbear donde dice View.post() no se garantiza que funcione? Tengo curiosidad porque también confío en este método para obtener el tamaño de una vista después del diseño y no sabía que no era confiable. - Tony Chan

@Turbo Digo que: p Usamos esa solución antes y resultó no ser confiable. Esa solución alternativa se basa en la suposición de que el diseño inicial se realiza dentro del mismo turno de UIThread que la inicialización. Por lo tanto, puede programar su código para que se ejecute antes del próximo turno de IU a través de post () y estar bien. Resultó que el diseño podría llevar más tiempo en determinadas circunstancias y la vista todavía no estaba diseñada cuando se ejecutó el código publicado. Lo que hago ahora es agregar ViewTreeObserver en onCreate y eliminarlo después del primer onLayout. Inicie sus cosas durante ese primer onLayout. - Marsbear

@marsbear ¿importa cuál? View obtienes el ViewTreeObserver ¿de? ¿O comparten todos el mismo? - Tony Chan

(La respuesta de 2012, puede estar desactualizada) Si desea admitir una versión anterior de Honeycomb, deberá incluir compatibilidad con versiones anteriores de API 13. Algo como:

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Por supuesto, los métodos obsoletos eventualmente se eliminarán de los SDK más recientes, pero aunque todavía confiamos en que la mayoría de nuestros usuarios tengan Android 2.1, 2.2 y 2.3, esto es lo que nos queda.

Respondido el 22 de junio de 15 a las 23:06

Sí, esto fue en 2012. - digiphd

lo siento, permítame aclarar lo que quise decir. Es muy poco probable que alguien admita API <14 a partir del 6/22/2015 - sudocodificador

Probé todas las "soluciones" posibles sin éxito y me di cuenta de que la aplicación "Dalvik Explorer" de Elliott Hughes siempre muestra la dimensión correcta en cualquier dispositivo Android / versión del sistema operativo. Terminé mirando su proyecto de código abierto que se puede encontrar aquí: https://code.google.com/p/enh/

Aquí está todo el código relevante:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

EDITAR: versión ligeramente mejorada (evite disparar excepciones en la versión del sistema operativo no compatible):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

Respondido 19 Jul 13, 07:07

Esta es la única publicación aquí que tiene en cuenta las decoraciones de la ventana (barra de estado / barra de menú). funcionó muy bien para mí. - Andy Cochrane

Impresionante, sin embargo, nunca debería haber esperado excepciones de disparo de lógica empresarial. El disparo de excepción (incluso cuando se detecta) es horrible para el rendimiento. Además, está haciendo más trabajo del necesario si el SDK_INT es> 13. En su lugar, debe agregar algunos ifs en Build.VERSION.SDK_INT. - Erik B

@Erik B, estoy de acuerdo. Agregué una versión mejorada. Aún así, dejé la parte "desde SDK 1" en caso de que algo salga mal en try / catch (he visto muchas cosas malas en Android, especialmente cuando piensas que es imposible que algo salga mal, así que me gusta mantenerlo seguro :)) . De todos modos, no debería haber demasiada sobrecarga, ya que este cálculo debe hacerse solo una vez (por ejemplo, los valores podrían mantenerse en algunos atributos estáticos). - Dragan Marjanovic

Tenga en cuenta que este código tiene licencia GPL v3, lo que tiene implicaciones para su uso en aplicaciones de producción. - Poco charla

GPL y dependiendo de la reflexión para llamar a métodos que podrían no estar presentes en futuras versiones de Android. Mhhh - Michel

Manera más sencilla:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 

respondido 26 nov., 14:10

Para acceder a la altura de la barra de estado para dispositivos Android, preferimos una forma programática de obtenerla:

Código de muestra

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

La variable result da la altura en el píxel.

Para un acceso rápido

Ingrese la descripción de la imagen aquí

Para obtener más información sobre la altura de Title bar, Navigation bar y Content View, amablemente mira Tamaños de pantalla del dispositivo Android.

Respondido el 20 de junio de 20 a las 10:06

¡Justo lo que necesitaba! getResources().getDisplayMetrics().heightPixels + result da la altura de pantalla completa real. La respuesta de Dragan Marjanović también funciona, pero prefiero esta solución mucho más corta y sencilla. - Michel

Este enfoque está desactualizado a partir de Android Marshmallow. La altura de la barra de estado puede cambiar según el dispositivo o la versión de Android. Mejor uso OnApplyWindowInsetsListener. - Jan Heinrich Reimer

Primero obtener vista (por ejemplo, por findViewById()) y luego puedes usar getWidth () en la vista misma.

respondido 12 nov., 15:11

En realidad, así es como la documentación le dice que lo haga ... pero no tiene sentido si NO está usando una vista. es posible que esté utilizando otra cosa, por ejemplo, mglsurfaceview. - gcb

esto es mejor ya que la vista principal puede no tener el tamaño de la pantalla. Pero asegúrese de que esto se haga en un punto en el que la vista cuyo tamaño está consultando ya se haya trazado, que normalmente no estará dentro de onCreate (). Puede usar una devolución de llamada personalizada de onWindowFocusChanged (boolean hasFocus) que se llamará después de que se hayan medido todas las vistas, etc., asegurándose de que no recibirá dimensiones incorrectas para la vista que le interesa ... Dori

Tengo dos funciones, una para enviar el contexto y la otra para obtener la altura y el ancho en píxeles:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

y

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}

Respondido 09 Feb 14, 15:02

Necesitas agregar @SuppressLint("NewApi") justo encima de la firma de la función para poder compilar. - adil malik

Creo que es mejor obtener la altura y el ancho de una sola vez que en llamadas separadas a las API porque, de lo contrario, podrían estar desincronizadas. Esto podría suceder si la orientación de la pantalla cambia mientras se ejecuta el código. - Diana

Para escalar dinámicamente usando XML hay un atributo llamado "android: layout_weight"

El siguiente ejemplo, modificado de la respuesta de Synic en este hilo, muestra un botón que ocupa el 75% de la pantalla (peso = .25) y una vista de texto que ocupa el 25% restante de la pantalla (peso = .75).

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>

contestado el 23 de mayo de 17 a las 12:05

Este es el código que utilizo para la tarea:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

Parece lo suficientemente limpio y, sin embargo, se encarga de la desaprobación.

Respondido el 27 de diciembre de 12 a las 14:12

¿No es esta una solución mucho mejor? Métricas de visualización viene con todo lo que necesita y funciona desde API 1.

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

También puede obtener la pantalla real (incluidas las decoraciones de pantalla, como la barra de estado o la barra de navegación del software) usando obtenerMetricasReales, pero esto solo funciona en mayores de 17 años.

¿Me estoy perdiendo algo?

contestado el 12 de mayo de 13 a las 21:05

No resta espacio para los controles en pantalla (como en tabletas o dispositivos Nexus). Además, obtengo un valor diferente (750 frente a 800) en mi tableta de 10 ", dependiendo de si la actividad está activa cuando se realiza el cálculo. Pero para mis propósitos, esto está más que bien. ¡Gracias! Steven L.

Solo agregando a la respuesta de Francesco. El otro observador que es más apto, si desea averiguar la ubicación en la ventana o la ubicación en la pantalla es ViewTreeObserver.OnPreDrawListener ()

Esto también se puede usar para encontrar otros atributos de una vista que es mayoritariamente desconocida en el momento de onCreate (), por ejemplo, la posición desplazada, la posición escalada.

respondido 16 mar '12, 07:03

Usando el siguiente código en Activity.

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

respondido 19 mar '12, 14:03

Encuentra el ancho y el alto de la pantalla:

width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();

Con esto, podemos obtener el SDK 13 más reciente y superior.

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}

Respondido 10 Feb 14, 03:02

DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Respondido 10 Feb 14, 03:02

Encontré que esto hizo el truco.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

Respondido el 06 de enero de 12 a las 19:01

Genial, pero hay una cosa aterradora sobre este método en el código fuente: este comentario - Norbert

Necesito decir que si no estás en Activity, pero en View (o tener una variable de View escriba su alcance), no es necesario utilizar WINDOW_SERVICE. Entonces puedes usar al menos dos formas.

Primero:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

Segundo:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

Todos estos métodos que llamamos aquí no están en desuso.

respondido 16 mar '13, 02:03

public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}

Respondido 10 Feb 14, 03:02

Para obtener las dimensiones de la pantalla, utilice métricas de visualización.

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

Obtenga la altura y el ancho en píxeles

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;

respondido 21 nov., 17:10

Esta no es una respuesta para el OP, ya que quería las dimensiones de la pantalla en píxeles reales. Quería las dimensiones en "píxeles independientes del dispositivo" y reunir las respuestas desde aquí https://stackoverflow.com/a/17880012/253938 y aquí https://stackoverflow.com/a/6656774/253938 Se me ocurrió esto:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);

contestado el 23 de mayo de 17 a las 13:05

Puedes conseguir el altura tamaño usando:

getResources().getDisplayMetrics().heightPixels;

y anchura tamaño usando

getResources().getDisplayMetrics().widthPixels; 

Respondido 09 Oct 17, 15:10

Hay una forma no obsoleta de hacer esto usando DisplayMetrics (API 1), que evita el desorden de intentar / atrapar:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;

Respondido el 19 de diciembre de 12 a las 14:12

Envolvería el código getSize así:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}

Respondido 21 Abr '13, 14:04

Esto falla en un emulador que ejecuta Android 4.0 (API 14). - jww

Para quien esta buscando dimensión de pantalla utilizable sin Status Bar y Barra de acciones (también gracias a la respuesta de Swapnil):

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}

Respondido el 09 de Septiembre de 13 a las 10:09

Primero cargue el archivo XML y luego escriba este código:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

Muestra el ancho y el alto según la resolución de tu pantalla.

Respondido 09 Feb 14, 15:02

Siga los métodos siguientes:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}

Respondido 01 Jul 16, 20:07

Kotlin

fun getScreenHeight(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.heightPixels
}

fun getScreenWidth(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.widthPixels
}

Respondido el 20 de junio de 20 a las 10:06

Hay ocasiones en las que necesitas conocer las dimensiones precisas del espacio disponible para un diseño cuando estás en onCreate de una actividad. Después de pensarlo un poco, resolví esta forma de hacerlo.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

Si por alguna razón no desea agregar otra actividad al manifiesto de Android, puede hacerlo de esta manera:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    

Respondido el 09 de junio de 13 a las 11:06

Obviamente, también puede devolver la altura en el paquete. - steve waring

Si no desea la sobrecarga de WindowManagers, Points o Displays, puede tomar los atributos de alto y ancho del elemento de Vista superior en su XML, siempre que su alto y ancho estén configurados en match_parent. (Esto es cierto siempre que su diseño ocupe toda la pantalla).

Por ejemplo, si su XML comienza con algo como esto:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

Entonces findViewById(R.id.entireLayout).getWidth() devolverá el ancho de la pantalla y findViewById(R.id.entireLayout).getHeight() devolverá la altura de la pantalla.

Respondido el 26 de junio de 13 a las 19:06

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.