Ottieni le size dello schermo in pixel

Ho creato alcuni elementi personalizzati e vorrei sistematicamente collocarli nell'angolo in alto a destra ( n pixel dal bordo superiore e m pixel dal bordo destro). Pertanto ho bisogno di get la width dello schermo e l'altezza dello schermo e quindi impostare la posizione:

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

Come ottengo lo screenWidth e lo screenHeight nell'attività principale?

  • android.support.v7.widget.AppCompatButton non può essere lanciato in android.view.ViewGroup
  • Ordina la visualizzazione di liste per data Android
  • È ansible stilare gli stili dei font android con il lead e tracking?
  • Immagine di background di ActionBar
  • Avviare una nuova attività dal frammento
  • Aggiungi ViewPagerIndicator a Android Studio
  • Come get statistiche sull'uso di CPU su Android?
  • Caricamento di immagini diverse nell'elenco per l'adattamento personalizzato
  • Menu di overflow personalizzato di Android (senza barra di azione e nessun menubutton)
  • Lo studio Android non è in grado di risolvere com.google.android.gms.location.places.AutocompleteFilter
  • Quali sono WindowInsets?
  • Frammenti di Android. Sostenere un'AsyncTask durante la rotazione dello schermo o la modifica della configuration
  • 30 Solutions collect form web for “Ottieni le size dello schermo in pixel”

    Se si desidera che le size del display in pixel si possono utilizzare 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'attività puoi get l'impostazione predefinita tramite WINDOW_SERVICE :

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

    Prima di introdurre getSize (a livello API 13), è ansible utilizzare i methods getWidth e getHeight che sono ora getHeight :

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

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

    22 ottobre 2015

    Un altro modo è: DisplayMetrics

    Una struttura che descrive le informazioni generali su un display, come la dimensione, la densità e la scala dei caratteri. Per accedere ai membri di DisplayMetrics, inizializzare un object come questo:

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

    Possiamo usare widthPixels per get informazioni per:

    "La width assoluta del display in pixel".

    Esempio:

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

    Un modo è:

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

    E 'deprecato e si dovrebbe provare invece il seguente codice. Le prime due righe di codice forniscono gli objecs DisplayMetrics. Questi oggetti contengono i campi come heightPixels, widthPixels.

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

    Può non rispondere alla tua domanda, ma potrebbe essere utile sapere (lo stavo cercando quando sono venuto a questa domanda) che se hai bisogno di una dimensione della vista, ma il tuo codice viene eseguito quando il suo layout non è stato ancora stabilito (ad esempio in onCreate() ) è ansible impostare un ViewTreeObserver.OnGlobalLayoutListener con View.getViewTreeObserver().addOnGlobalLayoutListener() e inserire il codice corrispondente in cui è necessaria la dimensione della vista. La richiamata dell'ascoltatore verrà chiamata quando il layout sarà stato stabilito.

    (Risposta 2012 potrebbe essere scaduta) Se vuoi supportre il pre-honeycomb, dovrai mettere in compatibilità indietro prima dell'API 13. Qualcosa di simile:

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

    Naturalmente i methods deprecati saranno alla fine usciti dai più recenti SDK, ma mentre continuiamo a contare sulla maggior parte dei nostri utenti con Android 2.1, 2.2 e 2.3, questo è ciò che ci resta.

    Ho provato tutte le possibili "soluzioni" senza successo e ho notato che l'applicazione "Dalvik Explorer" di Elliott Hughes mostra sempre size corrette su qualsiasi versione di Android / OS. Ho finito per esaminare il suo progetto open source che si trova qui: https://code.google.com/p/enh/

    Ecco tutto il codice relativo:

     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 eccezioni di spegnimento sulla versione OS non supportta):

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

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

    Codice di esempio

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

    Il result variabile dà l'altezza nel pixel.

    Per un accesso rapido

    Inserisci qui l'immagine

    Per ulteriori informazioni sull'altezza della Title bar dei Title bar , della Title bar Navigation bar e della Content View , esamina gentilmente le size dello schermo di dispositivo Android .

    Modo più semplice:

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

    Ottieni prima la vista (ad esempio, da findViewById() ) e quindi si può utilizzare getWidth () nella vista stessa.

    Ho due funzioni, una per submit il context e l'altra get altezza e width 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; } 

    Per scalare dynamicmente utilizzando XML c'è un attributo chiamato "android: layout_weight"

    L'esempio riportto di seguito, modificato dalla risposta del sincrone su questo thread , mostra un button che occupa il 75% dello schermo (peso = .25) e una visualizzazione di text che riprende 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> 

    Questo è il codice che utilizzo 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 depreazione.

    Non è una soluzione molto migliore? DisplayMetrics è dotato di tutto il necessario e funziona da 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 ansible get il display effettivo (inclusi decori dello schermo, come Barra di stato o barra di navigazione del software) utilizzando getRealMetrics , ma questo funziona solo su 17+.

    Mi sto perdendo qualcosa?

    Basta aggiungere alla risposta di Francesco. L'altro osservatore più adatto, se vuoi scoprire la posizione in window o posizione nello schermo è ViewTreeObserver.OnPreDrawListener ()

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

    Trova la width e l'altezza dello schermo:

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

    Utilizzando questo, possiamo get l'SDK 13 più recente e superiore.

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

    Utilizzando il codice riportto di seguito in Attività.

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

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

    Primo:

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

    Secondo:

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

    Tutti questi methods che noi chiamiamo qui non sono deprecati.

    Ho trovato questo fatto il trucco.

     Rect dim = new Rect(); getWindowVisibleDisplayFrame(dim); 
     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); } } 

    Questa non è una risposta per l'OP, in quanto voleva le size del display in pixel reali. Volevo le size in "pixel indipendenti da dispositivi" e mettere insieme le risposte da qui https://stackoverflow.com/a/17880012/253938 e qui https://stackoverflow.com/a/6656774/253938 sono venuto in su con questo:

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

    C'è un modo non deprecato per farlo usando DisplayMetrics (API 1), che evita la confusione di tentativi / catture:

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

    Avrei avvolto il codice getSize come questo:

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

    Innanzitutto carichi il file XML e scrivi questo codice:

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

    Mostra la width e l'altezza in base alla risoluzione dello schermo.

    Segui i methods riportti di seguito:

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

    Ci sono momentjs in cui è necessario conoscere le size precise dello spazio disponibile per un layout quando si è inCreate di un'attività. Dopo qualche pensiero 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 si desidera aggiungere un'altra attività al manifest Android, è ansible 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(); } } 

    Se non si desidera l'overhead di WindowManagers, Points o Displays, è ansible afferrare gli attributi di altezza e width della voce di visualizzazione più alti nel tuo XML, a condizione che l'altezza e la width siano impostati a match_parent. (Questo è vero finché il layout assume l'integer schermo.)

    Ad esempio, se il tuo XML inizia con qualcosa di simile:

     <?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 width dello schermo e findViewById(R.id.entireLayout).getHeight() restituirà l'altezza dello schermo.

    Per chi cerca la dimensione dello schermo utilizzabile senza barra di stato e barra d'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); } 

    Ho un'triggerszione dello schermo di schermatura con una LinearLayout come una vista di root che ha match_parent per la sua width e altezza. Questo è il codice nel metodo onCreate() di tale attività. Utilizzo 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 methods visualizzati 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ò determina l'altezza e la width 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).

    Simple function compatible with lower versions as well.

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

    To use:

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

    Above answer won't work if the Display class will not work then you can get the width and height by below method.

     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; } 
    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.