Android ottenere le dimensioni dello schermo dell'orientamento dello schermo

Question

da Android 3.0 c'è una barra di navigazione con il pulsante Indietro e Home sul display. Ora, se ho la dimensione dello schermo come questo

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

di questo

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

ottengo valori diversi per il paesaggio e ritratto. Ecco un esempio quello che voglio dire:

Acer Iconia A500 modalità portrait: 800 x 1232 Acer Iconia A500 modalità paesaggio: 1280 x 752

per quanto ne so questo vale per tutti i dispositivi con tale barra di navigazione. (ad esempio, Samsung Galaxy Nexus, GalaxyTab 10.1 ecc.)

Ora la mia domanda è, se sono in modalità verticale, come posso ottenere i valori della modalità orizzontale e viceversa?

Answer 1

da Android 3 non è possibile con la api pubblica recuperare l'altezza e la larghezza. Puoi passare attraverso la riflessione. Cerca getRawHeigth/Width

Answer 2

Ecco la soluzione che funziona per me. Ho dimensioni reali dello schermo e quindi sottraggo l'altezza della barra di navigazione.

// 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; 
    } 

Se l'applicazione ha barra di stato

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

EDIT (26 settembre 2014): Ho riformulato il mio testo per contenere una risposta completa e non solo commento a soluzione Dmitri.

Ecco la parte che stiamo usando per calcolare l'altezza della barra di navigazione prima di rotazione:

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)); 
} 

allora possiamo calcolare la larghezza di vista e l'altezza dopo la rotazione:

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));