Come determinare la categoria delle dimensioni dello schermo del dispositivo (piccola, normale, grande, xlarge) usando il codice?

308

Esiste un modo per determinare la categoria di dimensioni dello schermo del dispositivo corrente, ad esempio small, normal, large, xlarge?

Non la densità, ma le dimensioni dello schermo.

android  screen  android-screen-support 
— vieux
fonte

Risposte:

420

Puoi usare la Configuration.screenLayoutmaschera di bit.

Esempio:

if ((getResources().getConfiguration().screenLayout & 
    Configuration.SCREENLAYOUT_SIZE_MASK) == 
        Configuration.SCREENLAYOUT_SIZE_LARGE) {
    // on a large screen device ...

}
— Jeff Gilfelt
fonte
31
Per ottenere il rilevamento x-large, assicurati di utilizzare target android-3.0 nel tuo progetto. Oppure usa il valore statico 4 per x-large.
— Peterdk,
5
Alcuni dispositivi possono avere una dimensione UNDEFINED dello schermo, quindi può essere utile anche verificare con Configuration.SCREENLAYOUT_SIZE_UNDEFINED.
— valerybodak,
Potresti usare> = per ottenere schermi grandi o più grandi?
— Andrew S,
150

Il codice in basso completa la risposta sopra, mostrando le dimensioni dello schermo come Toast.

//Determine screen size
if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
    Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
    Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
    Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Screen size is neither large, normal or small", Toast.LENGTH_LONG).show();
}

Questo codice di seguito mostra la densità dello schermo come Toast.

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density == DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
— Mel
fonte
Il brindisi è bello per i sub.
— MinceMan,
qualcuno può confermare extra-large?
— Nathan H,
68

La risposta di Jeff Gilfelt come metodo di supporto statico:

private static String getSizeName(Context context) {
    int screenLayout = context.getResources().getConfiguration().screenLayout;
    screenLayout &= Configuration.SCREENLAYOUT_SIZE_MASK;

    switch (screenLayout) {
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        return "small";
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        return "normal";
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        return "large";
    case 4: // Configuration.SCREENLAYOUT_SIZE_XLARGE is API >= 9
        return "xlarge";
    default:
        return "undefined";
    }
}
— qwertzguy
fonte
12 
private String getDeviceDensity() {
    int density = mContext.getResources().getDisplayMetrics().densityDpi;
    switch (density)
    {
        case DisplayMetrics.DENSITY_MEDIUM:
            return "MDPI";
        case DisplayMetrics.DENSITY_HIGH:
            return "HDPI";
        case DisplayMetrics.DENSITY_LOW:
            return "LDPI";
        case DisplayMetrics.DENSITY_XHIGH:
            return "XHDPI";
        case DisplayMetrics.DENSITY_TV:
            return "TV";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "XXHDPI";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "XXXHDPI";
        default:
            return "Unknown";
    }
}
— Pawan Maheshwari
fonte
1
Questo ottiene la densità dello schermo. La domanda specifica "Non la densità, ma le dimensioni dello schermo".
— Subaru Tashiro,
11

Grazie per le risposte sopra, che mi hanno aiutato molto :-) Ma per quelli (come me) costretti a supportare ancora Android 1.5 possiamo usare java reflection per retrocompatibilità:

Configuration conf = getResources().getConfiguration();
int screenLayout = 1; // application default behavior
try {
    Field field = conf.getClass().getDeclaredField("screenLayout");
    screenLayout = field.getInt(conf);
} catch (Exception e) {
    // NoSuchFieldException or related stuff
}
// Configuration.SCREENLAYOUT_SIZE_MASK == 15
int screenType = screenLayout & 15;
// Configuration.SCREENLAYOUT_SIZE_SMALL == 1
// Configuration.SCREENLAYOUT_SIZE_NORMAL == 2
// Configuration.SCREENLAYOUT_SIZE_LARGE == 3
// Configuration.SCREENLAYOUT_SIZE_XLARGE == 4
if (screenType == 1) {
    ...
} else if (screenType == 2) {
    ...
} else if (screenType == 3) {
    ...
} else if (screenType == 4) {
    ...
} else { // undefined
    ...
}
— A. Masson
fonte
2
Puoi scegliere come target l'ultima versione della piattaforma e fare riferimento alle costanti della Configurationclasse. Questi sono valori finali statici che verranno incorporati al momento della compilazione (ovvero, saranno sostituiti dai loro valori effettivi), quindi il tuo codice non si interromperà nelle versioni precedenti della piattaforma.
— Karakuri,
Bello, non lo sapevo ... Stai parlando di Android: targetSdkVersion?
— A. Masson,
1
Sì, è così che sceglieresti una versione particolare. Molte persone (almeno quello che ho visto) hanno impostato targetSdkVersionl'ultima versione.
— Karakuri,
9

Se vuoi conoscere facilmente la densità dello schermo e le dimensioni di un dispositivo Android, puoi utilizzare questa app gratuita (non è richiesta l'autorizzazione): https://market.android.com/details?id=com.jotabout.screeninfo

— mmathieum
fonte
3
Questa domanda non riguarda un dispositivo specifico, si tratta di programmare per più profili divice (che è un processo di sviluppo software importante quando si sviluppa per piattaforme mobili).
— mtmurdock
1
una buona app da sapere è disponibile sul mercato - sarebbe anche bello vedere il codice che l'app utilizza per fornire le sue informazioni
— Stan Kurdziel,
4
@StanKurdziel Il codice sorgente è pubblicato sotto la licenza open source MIT ed è disponibile su: github.com/mportuesisf/ScreenInfo
— mmathieum
Questo link è morto ora
— Vadim Kotov,
5

Hai bisogno di controllare per schermi xlarge e x..alta densità? Questo è il codice modificato dalla risposta scelta.

//Determine screen size
if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {     
    Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {     
    Toast.makeText(this, "Normal sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {     
    Toast.makeText(this, "Small sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {     
    Toast.makeText(this, "XLarge sized screen" , Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();
}

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density==DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XHIGH) {
    Toast.makeText(this, "DENSITY_XHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXHIGH) {
    Toast.makeText(this, "DENSITY_XXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXXHIGH) {
    Toast.makeText(this, "DENSITY_XXXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
}
— Tom McFarlin
fonte
[Densità] In questo caso è necessario essere in attività. Se sei fuori uso usa getWindowManager () questo codice WindowManager windowManager = (WindowManager) context .getSystemService (Context.WINDOW_SERVICE);
— Horkavlna,
3

Ecco una Xamarin. Versione Android della risposta di Tom McFarlin 

        //Determine screen size
        if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeLarge) {
            Toast.MakeText (this, "Large screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeNormal) {
            Toast.MakeText (this, "Normal screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeSmall) {
            Toast.MakeText (this, "Small screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeXlarge) {
            Toast.MakeText (this, "XLarge screen", ToastLength.Short).Show ();
        } else {
            Toast.MakeText (this, "Screen size is neither large, normal or small", ToastLength.Short).Show ();
        }
        //Determine density
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager.DefaultDisplay.GetMetrics (metrics);
        var density = metrics.DensityDpi;
        if (density == DisplayMetricsDensity.High) {
            Toast.MakeText (this, "DENSITY_HIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Medium) {
            Toast.MakeText (this, "DENSITY_MEDIUM... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Low) {
            Toast.MakeText (this, "DENSITY_LOW... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xhigh) {
            Toast.MakeText (this, "DENSITY_XHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxhigh) {
            Toast.MakeText (this, "DENSITY_XXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxxhigh) {
            Toast.MakeText (this, "DENSITY_XXXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else {
            Toast.MakeText (this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + density, ToastLength.Long).Show ();
        }
— ellechino
fonte
2
Per favore, non basta scaricare un po 'di codice, ma spiegare cosa hai fatto e come questo aiuta
— David Medenjak,
2

Prova questa funzione isLayoutSizeAtLeast (int screenSize)

Per controllare il piccolo schermo, almeno 320x426 dp e oltre getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_SMALL);

Per controllare lo schermo normale, almeno 320x470 dp e oltre getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_NORMAL);

Per controllare lo schermo grande, almeno 480x640 dp e sopra getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_LARGE);

Per controllare uno schermo extra-large, almeno 720x960 dp e sopra getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_XLARGE);

— Devendra Vaja
fonte
Bello! Tale metodo è disponibile anche a partire dal livello API 11!
— Enselic,
2

Nel 2018, se hai bisogno della risposta di Jeff a Kotlin, eccola qui:

  private fun determineScreenSize(): String {
    // Thanks to https://stackoverflow.com/a/5016350/2563009.
    val screenLayout = resources.configuration.screenLayout
    return when {
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_XLARGE -> "Xlarge"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_UNDEFINED -> "Undefined"
      else -> error("Unknown screenLayout: $screenLayout")
    }
  }
— Thuy Trinh
fonte
1

Non potresti farlo usando una risorsa stringa ed enum? È possibile definire una risorsa stringa con il nome della dimensione dello schermo, ad esempio PICCOLO, MEDIO o GRANDE. Quindi è possibile utilizzare il valore della risorsa stringa per creare un'istanza dell'enum.

  1. Definisci un Enum nel tuo codice per le diverse dimensioni dello schermo che ti interessano. 

    public Enum ScreenSize {
    SMALL,
    MEDIUM,
    LARGE,;
}

  2. Definisci una risorsa stringa, ad esempio screensize, il cui valore sarà SMALL, MEDIUM o LARGE. 

    <string name="screensize">MEDIUM</string>
  3. Inserisci una copia di screensizeuna risorsa stringa in ogni dimensione a cui tieni.
    Ad esempio, <string name="screensize">MEDIUM</string>andrebbe in valori-sw600dp / strings.xml e valori-medio / strings.xml e<string name="screensize">LARGE</string> andrebbe in sw720dp / strings.xml e valori-large / strings.xml.
  4. Nel codice, scrivi
    ScreenSize size = ScreenSize.valueOf(getReources().getString(R.string.screensize);
— Prof Mo
fonte
Questo è stato promettente ... Tuttavia ho testato con 3 dispositivi e il tablet sta ancora tornando PICCOLO quando mi aspetto GRANDE. I miei file string.xml sono definiti in valori-h1024dp, valori-h700dp e valori-h200dp con <string name = "screensize"> xxxxxx </string> corrispondente
— A. Masson,
1

Copia e incolla questo codice nel tuo Activitye quando viene eseguito sarà Toastla categoria delle dimensioni dello schermo del dispositivo.

int screenSize = getResources().getConfiguration().screenLayout &
        Configuration.SCREENLAYOUT_SIZE_MASK;

String toastMsg;
switch(screenSize) {
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        toastMsg = "Large screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        toastMsg = "Normal screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        toastMsg = "Small screen";
        break;
    default:
        toastMsg = "Screen size is neither large, normal or small";
}
Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();
— Alireza Ghanbarinia
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.