android - studio - xxhdpi devices list




Ottieni dimensioni dello schermo in pixel (20)

È necessario dire che, se non si è in Activity , ma in View (o si dispone di una variabile di tipo View nel proprio ambito), non è necessario utilizzare 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.

Ho creato alcuni elementi personalizzati e desidero posizionarli programmaticamente 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 ottengo screenWidth e screenHeight nell'attività principale?


(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.


Esiste un modo non deprecato di fare ciò usando 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;

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

Ho trovato questo ha fatto il trucco.

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

Ho un'attività splash screen con un 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).


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

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

Mi sto perdendo qualcosa?


Per accedere all'altezza della barra di stato dei 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);
}

Il result variabile fornisce l'altezza nel pixel.

Per un rapido accesso

Per ulteriori informazioni sull'altezza della Title bar del Title bar , della Title bar Navigation bar e della Content View , guarda gentilmente le dimensioni dello schermo del dispositivo Android .


Per ottenere le dimensioni dello schermo utilizzare i metronomi 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;

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


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 è ancora stato definito (ad esempio in onCreate() ) è possibile impostare un ViewTreeObserver.OnGlobalLayoutListener con View.getViewTreeObserver().addOnGlobalLayoutListener() e inserire il codice pertinente che richiede la dimensione della vista. Il callback dell'ascoltatore verrà chiamato quando il layout sarà stato disposto.


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.


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://.com/a/17880012/253938 e qui https://.com/a/6656774/253938 mi sono avvicinato 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);

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.


Se non si desidera il sovraccarico di WindowManager, Points o Display, è possibile acquisire gli attributi height e width dell'elemento View più in alto nel proprio XML, a condizione che l'altezza e la larghezza siano impostate 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.


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

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 ti danno 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;

Utilizzando il seguente codice in Attività.

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

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

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




dimensions