How to determine device screen size category (smal

问题:

Is there any way to determine the category of screen size of the current device, such as small, normal, large, xlarge?

Not the density, but the screen size.

回答1:

You can use the Configuration.screenLayout bitmask.

Example:

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

}

回答2:

The code below fleshes out the answer above, displaying the screen size as a 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();
}

This code below displays the screen density as a 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();
}

回答3:

Jeff Gilfelt\'s answer as a static helper method:

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

回答4:

Thanks for the answers above, that helped me a lot :-) But for those (like me) forced to still support Android 1.5 we can use java reflection for backward compatible:

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

回答5:

private String getDeviceResolution()
{
    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\";
    }
}

回答6:

If you want to easily know the screen density and size of an Android device, you can use this free app (no permission required): https://market.android.com/details?id=com.jotabout.screeninfo

回答7:

Need to check for xlarge screens & x..high densities? This is the altered code from the chosen answer.

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

回答8:

Here is a Xamarin.Android version of Tom McFarlin\'s answer

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

回答9:

Couldn\'t you do this using a string resource and enums? You can define a string resource that had the name of the screen size, such as SMALL, MEDIUM, or LARGE. Then you could use the value of the string resource to create an instance of the enum.

1. Define an Enum in your code for the different screen sizes you care about.

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

2. Define a string resource, say screensize, whose value will be either SMALL, MEDIUM, or LARGE.

   <string name=\"screensize\">MEDIUM</string>
   

3. Put a copy of screensize in a string resource in each dimension you care about.
   For example, <string name=\"screensize\">MEDIUM</string> would go in values-sw600dp/strings.xml and values-medium/strings.xml and <string name=\"screensize\">LARGE</string> would go in sw720dp/strings.xml and values-large/strings.xml.
4. In code, write
   ScreenSize size = ScreenSize.valueOf(getReources().getString(R.string.screensize);

回答10:

Copy and paste this code into your Activity and when it is executed it will Toast the device\'s screen size category.

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

回答11:

In 2018, if you need Jeff\'s answer in Kotlin, here it is:

  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\")
    }
  }

回答12:

Try this function isLayoutSizeAtLeast(int screenSize)

To check small screen, atleast 320x426 dp and above getResources().getConfiguration().isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_SMALL);

To check normal screen, atleast 320x470 dp and above getResources().getConfiguration().isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_NORMAL);

To check large screen, atleast 480x640 dp and above getResources().getConfiguration().isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE);

To check extra large screen, atleast 720x960 dp and above getResources().getConfiguration().isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_XLARGE);