Ottieni le dimensioni dello schermo in pixel

Question

Ho creato alcuni elementi personalizzati e voglio posizionarli a livello di codice nell'angolo in alto a destra ( n pixel dal bordo superiore e m pixel dal bordo destro) . Pertanto ho bisogno di ottenere la larghezza e l'altezza dello schermo e quindi impostare la posizione:

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

Come posso ottenere screenWidth e screenHeight nell'attività principale?

Answer 1

Se vuoi le dimensioni di visualizzazione in pixel puoi usare getSize :

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

Se non ti trovi in ?? Attività puoi ottenere il Display predefinito tramite WINDOW_SERVICE :

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

Se sei in un frammento e vuoi compierlo, usa solo Activity.WindowManager (in Xamarin.Android) o getActivity (). getWindowManager () (in java).

Prima dell'introduzione di getSize (nel livello API 13), è possibile utilizzare i metodi getWidth e getHeight che sono ora obsoleti:

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

Per il caso d'uso che stai descrivendo, tuttavia, un margine / riempimento nel layout sembra più appropriato.

Un altro modo è: DisplayMetrics

  

Una struttura che descrive informazioni generali su un display, come dimensioni, densità e ridimensionamento dei caratteri. Per accedere ai membri DisplayMetrics, inizializza un oggetto come questo:

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

Possiamo usare widthPixels per ottenere informazioni per:

  

" La larghezza assoluta del display in pixel. "

Esempio:

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

Answer 2

Un modo è:

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

È obsoleto e dovresti invece provare il seguente codice. Le prime due righe di codice forniscono gli oggetti DisplayMetrics . Questo oggetto contiene campi come heightPixels , widthPixels .

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

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

Answer 3

Potrebbe non rispondere alla tua domanda, ma potrebbe essere utile sapere (stavo cercando me stesso quando sono arrivato a questa domanda) che se hai bisogno della dimensione di una Vista ma il tuo codice viene eseguito quando il suo layout non è stato disposto ancora (ad esempio in onCreate () ) puoi impostare un ViewTreeObserver.OnGlobalLayoutListener con View.getViewTreeObserver (). addOnGlobalLayoutListener () e inserisci lì il codice pertinente che necessita della dimensione della vista. Il callback dell'ascoltatore verrà chiamato quando il layout sarà stato predisposto.

Answer 4

(risposta del 2012, potrebbe non essere aggiornata) Se si desidera supportare pre Honeycomb, è necessario inserire la compatibilità con le versioni precedenti prima dell'API 13. Qualcosa del tipo:

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

Ovviamente i metodi obsoleti verranno eventualmente eliminati dagli SDK più recenti, ma mentre continuiamo a fare affidamento sulla maggior parte dei nostri utenti con Android 2.1, 2.2 e 2.3, questo è ciò che ci resta.

Answer 5

Ho provato tutte le possibili soluzioni "quot". senza successo e ho notato che "Dalvik Explorer" di Elliott Hughes " l'app mostra sempre la dimensione corretta su qualsiasi dispositivo Android / versione del sistema operativo. Ho finito per guardare il suo progetto open source che può essere trovato qui: https://code.google.com/p/enh/

Ecco tutto il codice rilevante:

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

EDIT: versione leggermente migliorata (evita di generare eccezioni sulla versione del sistema operativo non supportata):

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

Answer 6

Modo più semplice:

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

Answer 7

Per accedere all'altezza della barra di stato per dispositivi Android, preferiamo un modo programmatico per ottenerlo:

Codice di esempio

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

La variabile risultato indica l'altezza nel pixel.

Per un accesso rapido

Per ulteriori informazioni sull'altezza di barra del titolo , barra di navigazione e visualizzazione contenuto , si prega di guardare Dimensioni dello schermo del dispositivo Android .

Answer 8

Prima ottieni la vista (ad es. con findViewById () ) e poi puoi usare getWidth () sulla vista stessa.

Answer 9

Ho due funzioni, una per inviare il contesto e l'altra per ottenere altezza e larghezza in pixel:

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

e

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

Answer 10

Per il ridimensionamento dinamico tramite XML esiste un attributo chiamato " android: layout_weight "

L'esempio seguente, modificato dalla risposta di Synic su questa discussione , mostra un pulsante che occupa il 75% dello schermo (peso = .25) e una vista di testo che occupa il restante 25% dello schermo (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>

Answer 11

Questo è il codice che uso per l'attività:

// `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();
}

Sembra abbastanza pulito eppure, si prende cura della deprecazione.

Answer 12

Non è una soluzione molto migliore? DisplayMetrics viene fornito con tutto il necessario e funziona dall'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;
}

Puoi anche ottenere la visualizzazione effettiva (compresi i decori dello schermo, come la barra di stato o la barra di navigazione del software) utilizzando getRealMetrics , ma funziona solo su 17+.

Mi manca qualcosa?

Answer 13

Sto solo aggiungendo alla risposta di Francesco. L'altro osservatore che è più adatto, se si desidera scoprire la posizione nella finestra o la posizione nella schermata è ViewTreeObserver.OnPreDrawListener ()

Questo può anche essere usato per trovare altri attributi di una vista che è per lo più sconosciuta al momento onCreate () ad es. la posizione di scorrimento, la posizione in scala.

Answer 14

Trova larghezza e altezza dello schermo:

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

Usando questo, possiamo ottenere l'ultimo e sopra SDK 13.

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

Answer 15

Utilizzo del seguente codice in Attività.

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

Answer 16

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

Answer 17

Ho scoperto che questo ha funzionato.

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

Answer 18

Devo dire che se non sei in Activity , ma in View (o hai una variabile di View nel tuo ambito) , non è necessario utilizzare WINDOW_SERVICE . Quindi puoi utilizzare almeno due modi.

Per prima cosa:

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

Secondo:

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

Tutti questi metodi che chiamiamo qui non sono deprecati.

Answer 19

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

Answer 20

Per ottenere le dimensioni dello schermo usare metrices di visualizzazione

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

Ottieni l'altezza e la larghezza in pixel

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

Answer 21

Questa non è una risposta per l'OP, poiché voleva le dimensioni del display in pixel reali. Volevo le dimensioni in "pixel indipendenti dal dispositivo" e mettere insieme le risposte da qui https://stackoverflow.com/a/ 17880012/253938 e qui https://stackoverflow.com/a/6656774/253938 ho trovato in questo modo:

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

Answer 22

Esiste un modo non deprecato per farlo utilizzando DisplayMetrics (API 1), che evita il disordine try / catch:

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

Answer 23

Vorrei racchiudere il codice getSize in questo modo:

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

Answer 24

Puoi ottenere la dimensione altezza usando:

getResources().getDisplayMetrics().heightPixels;

e la larghezza utilizzando

getResources().getDisplayMetrics().widthPixels; 

Answer 25

Per chi cerca dimensione dello schermo utilizzabile senza Barra di stato e Barra delle azioni (anche grazie alla risposta di 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);
}

Answer 26

Prima carica il file XML e poi scrivi questo codice:

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

Mostra larghezza e altezza in base alla risoluzione dello schermo.

Answer 27

Segui i metodi seguenti:

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

Answer 28

Ci sono momenti in cui è necessario conoscere le dimensioni precise dello spazio disponibile per un layout in onCreate di un'attività. Dopo qualche pensiero ho scoperto questo modo di farlo.

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

Se per qualche motivo non vuoi aggiungere un'altra attività al manifest di Android, puoi farlo in questo modo:

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

Answer 29

Se non si desidera il sovraccarico di WindowManager, Punti o Display, è possibile acquisire gli attributi di altezza e larghezza dell'elemento Visualizza più in alto nel proprio XML, purché la sua altezza e larghezza siano impostate su match_parent. (Questo è vero fino a quando il layout occupa l'intero schermo.)

Ad esempio, se il tuo XML inizia con qualcosa del genere:

<?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" >

Quindi findViewById (R.id.entireLayout) .getWidth () restituirà la larghezza dello schermo e findViewById (R.id.entireLayout) .getHeight () restituirà l'altezza dello schermo.

Answer 30

Ho un'attività splash screen con LinearLayout come vista di root che ha match_parent per la sua larghezza e amp; altezza. Questo è il codice nel metodo onCreate () di quell'attività. Uso queste misure in tutte le altre attività dell'app.

int displayWidth = getRawDisplayWidthPreHoneycomb();
int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
pf.setScreenParameters(displayWidth, usableDisplayHeight);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
    myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
        @Override
        public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
            if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                return;
            }
            int displayWidth = Math.min(right, bottom);
            int usableDisplayHeight = Math.max(right, bottom);
            pf.setScreenParameters(displayWidth, usableDisplayHeight);
        }
    });
}

Ecco le implementazioni per i metodi che vedi vengono chiamati sopra:

private int getRawDisplayWidthPreHoneycomb() {
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int widthPixels = displayMetrics.widthPixels;
    int heightPixels = displayMetrics.heightPixels;

    return Math.min(widthPixels, heightPixels);
}

private int getRawDisplayHeightPreHoneycomb() {
    WindowManager w = getWindowManager();
    Display d = w.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    d.getMetrics(metrics);

    int widthPixels = metrics.widthPixels;
    int heightPixels = metrics.heightPixels;

    return Math.max(widthPixels, heightPixels);
}

public int getStatusBarHeight() {
    int statusBarHeight = 0;

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

    return statusBarHeight;
}

Ciò comporta l'altezza e la larghezza del display utilizzabile, escluso qualsiasi tipo di barra (barra di stato, barra di navigazione), per tutte le versioni API e diversi tipi di dispositivi (telefoni e tablet).