come ottenere le dimensioni dello schermo di Android a livello di programmazione, una volta per tutte?



Answers

Usando DisplayMetrics puoi ottenere altezza e larghezza dello schermo di qualsiasi dispositivo. ecco il codice.

DisplayMetrics metrics; 
int width = 0, height = 0;

Nel tuo metodo onCreate

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


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

Prova questo.

Question

Come posso scoprire le dimensioni dello schermo a livello di programmazione, nelle unità utilizzate dagli eventi touch e Visualizza misura / layout? In altre parole, desidero le coordinate dell'angolo in basso a destra dello schermo, nel sistema di coordinate utilizzato dagli eventi di tocco ' getRawX()/getRawY() e View.getLocationOnScreen() .

Sono riluttante a chiamare l'evento desiderato / visualizzare le unità "pixel" poiché evidentemente ci sono diverse nozioni di "pixel" sul mio telefono in varie modalità e non si sommano a una storia coerente.

Vedo che questo è stato chiesto e ho risposto molto sullo e altrove, ma nessuna delle risposte funziona sul mio telefono (droid 4, android 4.1.2) in tutte le modalità:

(Wow!)

Questo è per il codice della libreria che deve funzionare indipendentemente dal fatto che l'app sia in "modalità di compatibilità dello schermo" (ovvero targetSdkVersion <= 10 nel manifest) o no, e inoltre non voglio fare ipotesi sulla posizione, dimensione o esistenza della barra di stato o di altre decorazioni dello schermo simili.

Ecco i fatti:

  1. il mio telefono (un droid 4 con Android 4.1.2) ha 540x960 pixel fisici, ovvero pochi punti luminosi colorati.

  2. la dimensione dello schermo nelle unità desiderate, dall'osservazione degli eventi tattili e delle misurazioni di vista, è 360x640 quando l'app è in modalità schermo compatibile, 540x960 quando l'app non è in modalità schermo compat. Questi sono i numeri che ho bisogno di trovare a livello di codice, senza dover muovere con gli eventi touch o Views per trovarli, ma sto riscontrando estrema difficoltà nel trovare qualsiasi API che restituisca questi numeri.

  3. Display e DisplayMetrics oggetti ottenuti in vari modi tutti sostengono che la dimensione dello schermo è 540x960 "pixel" (sia in modalità schermo compat o meno). Per essere precisi, tutto il resto dice sempre 540x960: DisplayMetrics. {Width, height} Pixels, Display.getSize (), Display.getRealSize (), Display.get {Width, Height} (),

  4. Gli oggetti di configurazione ottenuti in vari modi tutti dicono schermo {Larghezza, Altezza} Dp = 360x614 (sia in modalità schermo compat o meno). Non credo che rappresenti l'intero schermo, dal momento che le proporzioni sono sbagliate. (Penso che sia l'intero schermo meno la barra di stato, ho bisogno di tutto lo schermo.) Penso che sia sicuro dire che l'intero schermo è 360x640 dp, anche se non conosco alcuna API che restituisce quella 640.

  5. DisplayMetrics ottenuto in vari modi dice che "density" è 1.0f quando è in modalità compat screen, 1.5f quando non è in modalità compat screen.

  6. getWindow().getAttributes().{width,height} L'attività getWindow().getAttributes().{width,height} non è utile in quanto in genere contiene MATCH_PARENT anziché le dimensioni effettive. Ma a quanto pare posso ottenere la risposta desiderata da getWindow().getDecorView().getMeasured{Width,Height}() (che in realtà è sorprendente dal momento che decorView della finestra dell'attività non sembra occupare l'intero schermo; sembra che occupi lo schermo meno la barra di stato). Ma non voglio fare affidamento su questo perché se la finestra viene ridimensionata (appare una tastiera morbida? Qualcuno chiama window.setAttributes ()? O forse non sono affatto in un'attività), questo sarà chiaramente tutto sbagliato.

Comprendo che la seguente formula dovrebbe contenere: pixel = dp * densità Sembra essere d'accordo con tutti i numeri riportati ((3), (4), (5) sopra) quando non è in modalità di compatibilità dello schermo: 540x960 = 360x640 * 1,5 Ma in modalità di compatibilità dello schermo non si sommano: 540x960! = 360x640 * 1 Quindi, qualcosa non funziona.

La spiegazione più semplice, secondo me, è che i metodi elencati in (3) sopra stanno semplicemente dando la risposta sbagliata per "pixel" quando sono in modalità compat screen-- cioè, erano destinati a restituire 360x640 "pixel" ma sono erroneamente restituendo 540x960 invece. Ma ci possono essere altri modi per guardarlo.

In ogni caso, ottenere i numeri desiderati indipendentemente dalla modalità, dai suddetti pezzi del puzzle, è certamente un puzzle difficile. Ho trovato un modo che sembra funzionare sul mio telefono in entrambe le modalità, ma è estremamente tortuoso, e si basa su due ipotesi che sembrano ancora piuttosto traballanti (come descritto nei commenti del codice qui sotto).

Ecco la mia ricetta:

/** get screen size in "pixels", i.e. touchevent/view units.
* on my droid 4, this is 360x640 or 540x960
* depending on whether the app is in screen compatibility mode
* (i.e. targetSdkVersion<=10 in the manifest) or not. */
public void getScreenSizePixels(int widthHeightInPixels[/*2*/])
{
    Resources resources = getResources();
    Configuration config = resources.getConfiguration();
    DisplayMetrics dm = resources.getDisplayMetrics();
    // Note, screenHeightDp isn't reliable
    // (it seems to be too small by the height of the status bar),
    // but we assume screenWidthDp is reliable.
    // Note also, dm.widthPixels,dm.heightPixels aren't reliably pixels
    // (they get confused when in screen compatibility mode, it seems),
    // but we assume their ratio is correct.
    double screenWidthInPixels = (double)config.screenWidthDp * dm.density;
    double screenHeightInPixels = screenWidthInPixels * dm.heightPixels / dm.widthPixels;
    widthHeightInPixels[0] = (int)(screenWidthInPixels + .5);
    widthHeightInPixels[1] = (int)(screenHeightInPixels + .5);
}

C'è un modo migliore / più pulito per trovare la dimensione dello schermo ??




Penso che questa funzione ti aiuterà a ottenere semplicemente la larghezza e l'altezza della tua dimensione dello schermo Android. La funzione restituisce la larghezza e l'altezza come una matrice di numeri interi come mostrato di seguito

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

e sul tuo metodo di creazione emetti la larghezza e l'altezza come mostrato di seguito

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);

Scarica il codice sorgente e provalo sul tuo Android Studio




Dovrei metterlo come commento ma non ho il rappresentante per quello.
Questa potrebbe non essere una risposta completamente corretta ma ho ottenuto le mie dimensioni quando ho cambiato altezza e larghezza nel metodo DisplayMetrics.

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

come ho detto questo potrebbe non essere corretto, ma non so perché, ma ha funzionato per me.




Ho usato il teorema di Pitagora per trovare le dimensioni diagonali dello schermo del telefono / tablet Android, lo stesso principio può essere applicato allo schermo di iPhone o Blackberry.

DisplayMetrics met = new DisplayMetrics();                
this.getWindowManager().getDefaultDisplay().getMetrics(met);// get display metrics object
String strSize = 
new DecimalFormat("##.##").format(Math.sqrt(((met.widthPixels / met.xdpi) *
(met.widthPixels / met.xdpi)) +
((met.heightPixels / met.ydpi) * (met.heightPixels / met.ydpi))));
// using Dots per inches with width and height

Pitagora doveva essere un genio, conosceva la programmazione degli smartphone tanti anni fa: p




Related



Tags

android android