android obtener el tamaño de la pantalla de la otra orientación de la pantalla

Question

desde android 3.0 hay una barra de navegación con la parte posterior y el botón de inicio en la pantalla. Ahora bien, si consigo el tamaño de la pantalla como esta

ClockLwp.ScreenHeight = getWindowManager().getDefaultDisplay().getHeight(); 
ClockLwp.ScreenWidth = getWindowManager().getDefaultDisplay().getWidth(); 

de esta

getResources().getDisplayMetrics().widthPixels 
getResources().getDisplayMetrics().heightPixels 

consigo diferentes valores para el paisaje y el retrato. Este es un ejemplo de lo que quiero decir:

modo vertical A500 de Acer Iconia: 800 x 1232 Acer Iconia A500 modo de paisaje: 1280 x 752

Aparentemente, este se aplica a todos los dispositivos con tal barra de navegación. (por ejemplo, Samsung Galaxy Nexus, GalaxyTab 10.1, etc.)

Ahora mi pregunta es, si estoy en modo retrato ¿cómo puedo obtener los valores del modo horizontal y viceversa?

Answer 1

desde android 3 no hay forma de que la API pública recupere el alto y el ancho sin procesar. Puedes pasar por la reflexión. Busque getRawHeigth/Width

Answer 2

Aquí hay una solución que me funciona. Tengo un tamaño de pantalla real y luego restar la altura de la barra de navegación.

// get navigation bar height for landscape and portrait modes 
    Resources resources = activity.getResources(); 
    int resourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android"); 
    int resourceIdLandscape = resources.getIdentifier("navigation_bar_height_landscape", "dimen", "android"); 
    int portraitNavBarHeight = 0; 
    int landscapeNavBarHeight = 0; 

    boolean hasPermanentMenuKey = ViewConfiguration.get(activity).hasPermanentMenuKey(); 
    if (resourceId > 0 && !hasPermanentMenuKey) { 
     portraitNavBarHeight = resources.getDimensionPixelSize(resourceId); 
    } 

    if (resourceIdLandscape > 0 && !hasPermanentMenuKey) { 
     landscapeNavBarHeight = resources.getDimensionPixelSize(resourceIdLandscape); 
    } 

    // get real screen size 
    DisplayMetrics displayMetrics = new DisplayMetrics(); 
    WindowManager wm = (WindowManager) activity.getSystemService(Context.WINDOW_SERVICE); 
    Display disp = wm.getDefaultDisplay(); 

    int API_LEVEL = android.os.Build.VERSION.SDK_INT; 
    if (API_LEVEL >= 17) { 
     disp.getRealMetrics(displayMetrics); 
    } else { 
     disp.getMetrics(displayMetrics); 
    } 

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

    // size for orientation 
    int portraitHeight; 
    int portraitWidth; 
    int landscapeHeight; 
    int landscapeWidth; 

    if(width > height) { 
     portraitHeight = width - portraitNavBarHeight; 
     portraitWidth = height; 

     landscapeHeight = height - landscapeNavBarHeight; 
     landscapeNavBarHeight = width; 

    } else { 
     portraitHeight = height - portraitNavBarHeight; 
     portraitWidth = width; 

     landscapeHeight = width - landscapeNavBarHeight; 
     landscapeNavBarHeight = height; 
    } 

Si la aplicación tiene barra de estado

public static int getStatusBarHeight(Context context) { 
    Resources resources = context.getResources(); 
    int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android"); 
    if (resourceId > 0) { 
     return resources.getDimensionPixelSize(resourceId); 
    } 
    return 0; 
} 

Answer 3

EDITAR (26 de septiembre de 2014): I reformulada mi texto para contener una respuesta completa y no sólo comentario a Dimitri solución.

Aquí es la parte que estamos utilizando para el cálculo de la altura de la barra de navegación antes de la rotación:

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

/* 
* We need to take system resources here to verify navigation 
* bar height. Application resources also contains navigation bar 
* height but this value is not valid for some devices e.g. Nexus 7 (2012)! 
*/ 
Resources appRes = getResources(); 
Resources sysRes = Resources.getSystem(); 
boolean landscapeMode = (metrics.widthPixels > metrics.heightPixels); 
/* Check if the device has navigation bar. There is no direct API for 
* that so we use some hacking that may not always work, 
* (see http://stackoverflow.com/questions/16092431/check-for-navigation-bar) 
* but this method should be enough for most devices. 
* TODO: Find a more consistent way. For our needs it is currently enough as we 
* support limited set of devices. 
*/ 
boolean hasNavigationBar = !ViewConfiguration.get(getContext()).hasPermanentMenuKey(); 
int navBarHeight = 0; 
int navBarHeightRotated = 0; 
if (hasNavigationBar) { 
    int barHeightDimId = 0; 
    int barHeightDimIdRotated = 0; 
    if (landscapeMode) { 
     barHeightDimId = sysRes.getIdentifier(
       "navigation_bar_height_landscape", "dimen", "android"); 
     barHeightDimIdRotated = sysRes.getIdentifier(
       "navigation_bar_height", "dimen", "android"); 
    } else { 
     barHeightDimIdRotated = sysRes.getIdentifier(
       "navigation_bar_height_landscape", "dimen", "android"); 
     barHeightDimId = sysRes.getIdentifier("navigation_bar_height", 
       "dimen", "android"); 
    } 
    if (barHeightDimId != 0) { 
     navBarHeight = appRes.getDimensionPixelSize(barHeightDimId); 
    } 
    if (barHeightDimIdRotated != 0) { 
     navBarHeightRotated = appRes 
       .getDimensionPixelSize(barHeightDimIdRotated); 
    } 
    NCLogs.i("MyApp", String.format("Android navigation bar height: %d (current), %d (after rotation)", navBarHeight, navBarHeightRotated)); 
} 

entonces podemos calcular nuestra anchura de la vista y la altura después de la rotación:

int realScreenHeight = metrics.heightPixels + navBarHeight; 

// We expect to not have decor views near the left or right borders 
int realScreenWidth = metrics.widthPixels; 

/* 
* Height of decor views: system status bar + any application addtional elements + 
* + system navigation bar 
*/ 
int decorHeightRotated = realScreenHeight - getHeight() - navBarHeight + navBarHeightRotated; 

int viewWidthRotated = realScreenHeight; 
int viewHeightRotated = (realScreenWidth - decorHeightRotated); 
NCLogs.i("MyApp", String.format("Width after rotation: %d, Height after rotation: %d", viewWidthRotated, viewHeightRotated));