risposta-alla-domanda-sullo-sviluppo-web-bd.com

Ottieni dimensioni dello schermo in pixel

Ho creato alcuni elementi personalizzati e desidero posizionarli in modo programmatico nell'angolo in alto a destra (n pixel dal bordo superiore e m pixel dall'angolo 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 ottengo screenWidth e screenHeight nell'attività principale?

1740
Niko Gamulin

Se vuoi le dimensioni dello schermo 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 sei in un Activity puoi ottenere il valore predefinito Display via WINDOW_SERVICE:

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

Se sei in un frammento e vuoi comporlo, usa Activity.WindowManager (in Xamarin.Android) o getActivity (). GetWindowManager () (in Java).

Prima che getSize fosse introdotto (nel livello API 13), potevi usare i metodi getWidth e getHeight che ora sono deprecati:

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 le informazioni generali su un display, come le dimensioni, la densità e il ridimensionamento dei caratteri. Per accedere ai membri di DisplayMetrics, inizializzare 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);
3398
Josef Pfleger

Un modo è:

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

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

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;
359
Balaji.K

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

114

(Risposta 2012, potrebbe non essere aggiornata) Se si desidera supportare pre Honeycomb, sarà necessario ripristinare la compatibilità prima dell'API 13. Qualcosa come:

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 deprecati finiranno per essere presi fuori dagli SDK più recenti, ma mentre continuiamo a fare affidamento sulla maggior parte dei nostri utenti che hanno Android 2.1, 2.2 e 2.3, questo è ciò che ci rimane.

104
digiphd

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

Ecco tutto il codice pertinente:

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 (evitare l'attivazione di eccezioni sulla versione del sistema operativo non supportato):

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

Modo più semplice: 

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

Per accedere all'altezza della barra di stato per i 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 result fornisce l'altezza nel pixel.

Per un rapido accesso

Enter image description here

Per ulteriori informazioni sull'altezza di Title bar, Navigation bar e Content View, guarda gentilmente Dimensioni schermo dispositivo Android.

46
Swapnil Sonar

Per prima cosa ottieni la vista (ad esempio con findViewById()) e poi puoi usare getWidth () sulla vista stessa.

30
Marcin Gil

Ho due funzioni, una per l'invio del 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;
}
26
Elenasys

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 e ancora, si prende cura della deprecazione.

17
Pijusn

Non è una soluzione molto migliore? DisplayMetrics viene fornito con tutto ciò di cui hai bisogno e funziona con l'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;
}

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

Mi sto perdendo qualcosa?

17
David Corsalini

Per scalare dinamicamente usando XML c'è un attributo chiamato "Android: layout_weight" 

L'esempio seguente, modificato dalla risposta di synic su questo thread , mostra un pulsante che occupa il 75% dello schermo (peso = 0,25) e una visualizzazione 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>
17
Crbreingan

Trova larghezza e altezza dello schermo:

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

Usando questo, possiamo ottenere l'ultimo e sopra l'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);
}
15
NagarjunaReddy

Aggiungendo solo la risposta di Francesco. L'altro osservatore che è più adatto, se vuoi scoprire la posizione nella finestra o nella posizione nello schermo is 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 a scorrimento, la posizione in scala.

15
pellucide
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;
14
Cristiana Chavez

Utilizzando il seguente codice in Attività.

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

Ho trovato questo ha fatto il trucco.

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

Devi dire che se non sei in Activity, ma in View (o hai una variabile di tipo View nel tuo scope), non c'è bisogno di usare WINDOW_SERVICE. Quindi puoi usare almeno due modi.

Primo:

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

Secondo:

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

Tutti questi metodi che chiamiamo qui non sono deprecati.

11
Sergei Pikalev
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);
    }
}
11

Per ottenere le dimensioni dello schermo utilizzare le metriche 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;
9
Anonymous

Questa non è una risposta per l'OP, poiché voleva le dimensioni dello schermo in pixel reali. Volevo le dimensioni in "pixel indipendenti dal dispositivo" e unendo le risposte da qui https://stackoverflow.com/a/17880012/253938 e qui https://stackoverflow.com/a/ 6656774/253938 Mi sono inventato questo:

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

Esiste un modo non deprecato di fare ciò usando DisplayMetrics (API 1), che evita la confusione 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;
7
paulrehkugler

Puoi ottenere la dimensione height usando:

getResources().getDisplayMetrics().heightPixels;

e la dimensione width usando

getResources().getDisplayMetrics().widthPixels; 
7
Jéwôm'

Vorrei avvolgere 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;
}
7
Simon Heinen

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.

5
duggu

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

Per chi sta cercando dimensione schermo utilizzabile senza Barra di stato e Barra di azione (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);
}
5

Ci sono momenti in cui è necessario conoscere le dimensioni precise dello spazio disponibile per un layout quando ci si trova in un activity onCreate . Dopo un po 'di riflessione ho elaborato 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();
    }
}    
4
Steve Waring

Se non vuoi il sovraccarico di WindowManager, Points o Display, puoi prendere gli attributi height e width dell'elemento View più in alto nel tuo XML, a condizione che altezza e larghezza siano impostati su match_parent. (Questo è vero finché 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.

4
christinac

Ho un'attività splash screen con LinearLayout come una vista root che ha match_parent per la sua larghezza e altezza. Questo è il codice nel metodo onCreate() di quell'attività. Io 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 richiamati 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ò si traduce in altezza e larghezza del display utilizzabile, escludendo qualsiasi tipo di barre (barra di stato, barra di navigazione), per tutte le versioni API e diversi tipi di dispositivi (telefoni e tablet).

3
Rutger

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
}
2
Khemraj

La risposta sopra non funzionerà se la classe Display non funzionerà, quindi puoi ottenere la larghezza e l'altezza con il metodo seguente.

private static final int WIDTH_INDEX = 0;
private static final int HEIGHT_INDEX = 1;

    public static int[] getScreenSize(Context context) {
        int[] widthHeight = new int[2];
        widthHeight[WIDTH_INDEX] = 0;
        widthHeight[HEIGHT_INDEX] = 0;

        try {
            WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Display display = windowManager.getDefaultDisplay();

            Point size = new Point();
            display.getSize(size);
            widthHeight[WIDTH_INDEX] = size.x;
            widthHeight[HEIGHT_INDEX] = size.y;

            if (!isScreenSizeRetrieved(widthHeight))
            {
                DisplayMetrics metrics = new DisplayMetrics();
                display.getMetrics(metrics);
                widthHeight[0] = metrics.widthPixels;
                widthHeight[1] = metrics.heightPixels;
            }

            // Last defense. Use deprecated API that was introduced in lower than API 13
            if (!isScreenSizeRetrieved(widthHeight)) {
                widthHeight[0] = display.getWidth(); // deprecated
                widthHeight[1] = display.getHeight(); // deprecated
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return widthHeight;
    }

    private static boolean isScreenSizeRetrieved(int[] widthHeight) {
        return widthHeight[WIDTH_INDEX] != 0 && widthHeight[HEIGHT_INDEX] != 0;
    }
2
Maharshi Saparia

Semplice funzione compatibile anche con versioni inferiori.

/**
 * @return screen size int[width, height]
 *
 * */
public int[] getScreenSize(){
    Point size = new Point();
    WindowManager w = getWindowManager();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2){
        w.getDefaultDisplay().getSize(size);
        return new int[]{size.x, size.y};
    }else{
        Display d = w.getDefaultDisplay();
        //noinspection deprecation
        return new int[]{d.getWidth(), d.getHeight()};
    }
}

Usare:

int width = getScreenSize()[0];
int height = getScreenSize()[1];
1
Jakob

Ecco un semplice adattamento da alcune risposte sopra in un'implementazione di Kotlin. Richiede come menzionato sopra windowsSoftInput = "adjustResize" nel manifest:

class KeyboardWatcher(private val layoutRooView: View) {

    companion object {
        private const val MIN_KEYBOARD_HEIGHT = 200f
    }

    private val displayMetrics: DisplayMetrics = layoutRooView.resources.displayMetrics
    private var stateVisible = false

    var observer: ((Boolean) -> Unit)? = null

    init {
        layoutRooView.viewTreeObserver.addOnGlobalLayoutListener {
            val heightDiff = layoutRooView.rootView.height - layoutRooView.height
            if (!stateVisible && heightDiff > dpToPx(MIN_KEYBOARD_HEIGHT)) {
                stateVisible = true
                observer?.invoke(stateVisible)
            } else if(stateVisible) {
                stateVisible = false
                observer?.invoke(stateVisible)
            }
        }
    }

    private fun dpToPx(valueInDp: Float): Float {
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, valueInDp, displayMetrics)
    }
}

E da usare:

val activityRootView = findViewById<ViewGroup>(R.id.activityRoot)
KeyboardWatcher(activityRootView).observer = { visible ->
    if (visible) do something here ...
}
1
Joao Gavazzi

Questa funzione restituisce la dimensione approssimativa dello schermo in pollici.

public double getScreenSize()
{
        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        int width=dm.widthPixels;
        int height=dm.heightPixels;
        int dens=dm.densityDpi;
        double wi=(double)width/(double)dens;
        double hi=(double)height/(double)dens;
        double x = Math.pow(wi,2);
        double y = Math.pow(hi,2);
        double screenInches = Math.sqrt(x+y);
        return screenInches;
}
1
Abhishek
DisplayMetrics dm = getResources().getDisplayMetrics();
float fwidth = dm.density * dm.widthPixels;
float fheight = dm.density * dm.heightPixels;

Se getSize ti dà un errore a causa della tua minSDKVersion e non vuoi usare metodi deprecati (getWidth e getHeight), la soluzione getMetrics è stata originariamente pubblicata nel 2011 da Balaji.K ... E Nik ha aggiunto un commento che spiega getDisplayMetrics considera anche la dimensione della barra di stato.

Alcuni altri commenti si riferiscono a moltiplicare per la scala ( density ) per ottenere il valore float preciso delle dimensioni. Testato su Android v2.2 (API 8) e v4.0 con buoni risultati e senza errori/avvisi .

0
Armfoot

Penso che sia più semplice

private fun checkDisplayResolution() {
    val displayMetrics = DisplayMetrics().also {
        windowManager.defaultDisplay.getMetrics(it)
    }

    Log.i(TAG, "display width: ${displayMetrics.widthPixels}")
    Log.i(TAG, "display height: ${displayMetrics.heightPixels}")
    Log.i(TAG, "display width dpi: ${displayMetrics.xdpi}")
    Log.i(TAG, "display height dpi: ${displayMetrics.ydpi}")
    Log.i(TAG, "display density: ${displayMetrics.density}")
    Log.i(TAG, "display scaled density: ${displayMetrics.scaledDensity}")
}
0
Artem Botnev

Ho usato le proposte di cui sopra e ho creato una versione kotlin per la nostra domanda. Spero che questo fornisca un ulteriore aiuto per coloro che usano Kotlin:

private val screenDimensions: Int by lazy {
    val display = (context.getSystemService(Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
    Point()
        .also { size ->
            when {
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 -> display.getRealSize(size)
                else -> display.getSize(size)
            }
        }
}

screenDimensions.x // width
screenDimensions.y // height
0
Mike T

Si noti che l'altezza restituita da queste API sarà INFERIORE ALL'altezza fisica del dispositivo poiché l'altezza della barra dei pulsanti viene sottratta.

Ad esempio: in una Moto X4 restituisce il widthPixels corretto (1080) ma restituisce un'altezza di 1776 anche se lo schermo del dispositivo è alto 1920 pixel.

0
Tyler