Obtener el ancho de la pantalla y la altura

Question

¿Cómo puedo conseguir ancho de la pantalla y la altura para el uso de este valor en

@Override protected void onMeasure(int widthSpecId, int heightSpecId) { 
    Log.e(TAG, "onMeasure" + widthSpecId); 
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
     game.findViewById(R.id.flag).getHeight()); 
} 

Answer 1

Utilizando este código se puede obtener en tiempo de ejecución Display's Width & Height

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

---

En una vista en la que necesita hacer algo como esto:

((Activity) getContext()).getWindowManager() 
         .getDefaultDisplay() 
         .getMetrics(displayMetrics); 

Answer 2

Sólo para actualizar la respuesta por Parag y SPK para alinearse con la corriente de compatibilidad con versiones anteriores del SDK de métodos obsoletos:

int Measuredwidth = 0; 
int Measuredheight = 0; 
Point size = new Point(); 
WindowManager w = getWindowManager(); 

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { 
    w.getDefaultDisplay().getSize(size); 
    Measuredwidth = size.x; 
    Measuredheight = size.y; 
}else{ 
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
} 

Answer 3

Try a continuación código: -

1.

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

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

o

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

3.

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

metrics.heightPixels; 
metrics.widthPixels; 

Answer 4

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

Answer 5

¿Por qué no

DisplayMetrics displaymetrics = getResources() getDisplayMetrics().;

a continuación, utilizar

displayMetrics.widthPixels (heightPixels)

Answer 6

métodos mostrados aquí están en desuso/anticuado, pero esto sigue siendo working.Require API 13

comprobar que funciona

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

Answer 7

Obtenga el valor de ancho y alto de la pantalla.

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

Answer 8

Hay una respuesta muy simple y sin contexto pase

public static int getScreenWidth() { 
    return Resources.getSystem().getDisplayMetrics().widthPixels; 
} 

public static int getScreenHeight() { 
    return Resources.getSystem().getDisplayMetrics().heightPixels; 
} 

Nota: si desea que la altura incluir barra de navegación, utilice el método de abajo

WindowManager windowManager = 
     (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE); 
    final Display display = windowManager.getDefaultDisplay(); 
    Point outPoint = new Point(); 
    if (Build.VERSION.SDK_INT >= 19) { 
     // include navigation bar 
     display.getRealSize(outPoint); 
    } else { 
     // exclude navigation bar 
     display.getSize(outPoint); 
    } 
    if (outPoint.y > outPoint.x) { 
     mRealSizeHeight = outPoint.y; 
     mRealSizeWidth = outPoint.x; 
    } else { 
     mRealSizeHeight = outPoint.x; 
     mRealSizeWidth = outPoint.y; 
    } 

Answer 9

DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics(); 
int widthPixels = lDisplayMetrics.widthPixels; 
int heightPixels = lDisplayMetrics.heightPixels; 

Answer 10

Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay(); 
int mWidthScreen = display.getWidth(); 
int mHeightScreen = display.getHeight(); 

Answer 11

Solo use t que funciona por debajo de ese devuelve la anchura y la altura del tamaño de la pantalla como una matriz de enteros

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; 

    } 

En su función o botón onCreate haga clic en añadir el siguiente código a la salida de los tamaños de pantalla 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); 

Answer 12

public class DisplayInfo { 
    int screen_height=0, screen_width=0; 
    WindowManager wm; 
    DisplayMetrics displaymetrics; 

    DisplayInfo(Context context) { 
     getdisplayheightWidth(context); 
    } 

    void getdisplayheightWidth(Context context) { 
     wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); 
     displaymetrics = new DisplayMetrics(); 
     wm.getDefaultDisplay().getMetrics(displaymetrics); 
     screen_height = displaymetrics.heightPixels; 
     screen_width = displaymetrics.widthPixels; 
    } 

    public int getScreen_height() { 
     return screen_height; 
    } 

    public int getScreen_width() { 
     return screen_width; 
    } 
} 

Answer 13

 @Override 
     protected void onPostExecute(Drawable result) { 
      Log.d("width",""+result.getIntrinsicWidth()); 
      urlDrawable.setBounds(0, 0, 0+result.getIntrinsicWidth(), 600); 

      // change the reference of the current drawable to the result 
      // from the HTTP call 
      urlDrawable.drawable = result; 

      // redraw the image by invalidating the container 
      URLImageParser.this.container.invalidate(); 

      // For ICS 
      URLImageParser.this.container.setHeight((400+URLImageParser.this.container.getHeight() 
        + result.getIntrinsicHeight())); 

      // Pre ICS`enter code here` 
      URLImageParser.this.container.setEllipsize(null); 
     } 

Answer 14

manera completa para hacerlo, que devuelve la verdadera resolución:

  WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); 
      Point size = new Point(); 
      wm.getDefaultDisplay().getRealSize(size); 
      final int width = size.x, height = size.y; 

Y puesto que esto puede cambiar en la orientación diferente, he aquí una solución (en Kotlin), para hacerlo bien sin importar la orientación:

/** 
* returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br> 
* The result should be consistent no matter the orientation of the device 
*/ 
@JvmStatic 
fun getScreenNaturalOrientation(context: Context): Int { 
    //based on : http://stackoverflow.com/a/9888357/878126 
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager 
    val config = context.resources.configuration 
    val rotation = windowManager.defaultDisplay.rotation 
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT) 
     Configuration.ORIENTATION_LANDSCAPE 
    else 
     Configuration.ORIENTATION_PORTRAIT 
} 

/** 
* returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device 
*/ 
@JvmStatic 
fun getScreenNaturalSize(context: Context): Point { 
    val screenNaturalOrientation = getScreenNaturalOrientation(context) 
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager 
    val point = Point() 
    wm.defaultDisplay.getRealSize(point) 
    val currentOrientation = context.resources.configuration.orientation 
    if (currentOrientation == screenNaturalOrientation) 
     return point 
    else return Point(point.y, point.x) 
} 

Answer 15

encontré Weigan 's mejor respuesta una en esta página, aquí es cómo se puede utilizar en la que Xamarin.Android:

public int GetScreenWidth() 
{ 
    return Resources.System.DisplayMetrics.WidthPixels; 
} 

public int GetScreenHeight() 
{ 
    return Resources.System.DisplayMetrics.HeightPixels; 
} 

Answer 16

resolución de la pantalla es total hay de píxel en la pantalla. El siguiente programa extraerá la resolución de pantalla del dispositivo. Imprimirá el ancho y alto de la pantalla. Esos valores están en pixel.

public static Point getScreenResolution(Context context) { 
// get window managers 
WindowManager manager = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE); 
Display display = manager.getDefaultDisplay(); 
Point point = new Point(); 
display.getSize(point); 

// get width and height 
int width = point.x; 
int height = point.y; 

return point; 

}

Answer 17

Este set of utilities a trabajar con la abstracción Tamaño en Android.

Contiene una clase SizeFromDisplay.java Se puede utilizar la siguiente manera:

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay()); 
size.width(); 
size.hight(); 

Answer 18

dos pasos. En primer lugar, extender la clase Actividad

class Example extends Activity 

Segundo: Utilice este código

DisplayMetrics displayMetrics = new DisplayMetrics(); 
WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE); 
windowmanager.getDefaultDisplay().getMetrics(displayMetrics); 
int deviceWidth = displayMetrics.widthPixels; 
int deviceHeight = displayMetrics.heightPixels;