Provide different bitmap drawables for different screen densities
@@ -432,6 +490,12 @@ configuration.
+Note: If you're developing your application for Android 3.2 and
+higher, see the section about Declaring Tablet Layouts for Android 3.2 for information about
+new configuration qualifiers that you should use when declaring layout resources for specific
+screen sizes (instead of using the size qualifiers in table 1).
+
For more information about how these qualifiers roughly correspond to real screen
sizes and densities, see Range of Screens Supported, earlier in this
document.
@@ -554,6 +618,267 @@ icons, status bar icons, tab icons, and more.
+
+Declaring Tablet Layouts for Android 3.2
+
+For the first generation of tablets running Android 3.0, the proper way to declare tablet
+layouts was to put them in a directory with the {@code xlarge} configuration qualifier (for example,
+ {@code res/layout-xlarge/}). In order to accommodate other types of tablets and screen
+sizes—in particular, 7" tablets—Android 3.2 introduces a new way to specify resources
+for more discrete screen sizes. The new technique is based on the amount of space your layout needs
+(such as 600dp of width), rather than trying to make your layout fit generalized size groups (such
+as large or xlarge).
+
+The reason designing for 7" tablets is tricky when using the generalized size groups is
+that a 7" tablet is technically in the same group as a 5" handset (the large group). While
+these two devices are seemingly close to each other in size, the amount of space for an
+application's UI is significantly different, as is the style of user interaction. Thus, a 7" and 5"
+screen should not always use the same layout. To make it possible for these two kinds of screens to
+offer different layouts, Android now allows you to specify your layout resources based on the width
+and/or height that's actually available for your application's layout, specified in dp units.
+
+For example, after you've designed the layout you want to use for tablet-style devices, you might
+determine that the layout stops working well when the screen is less than 600dp wide. This threshold
+thus becomes the minimum size that you require for your tablet layout. As
+such, you can now specify that these layout resources should be used only when there is at least
+600dp of width available for your application's UI.
+
+You should either pick a width and design to it as your minimum size, or test what is the
+smallest width your layout supports once it's complete.
+
+
+Using new size qualifiers
+
+The numbers describing the width and height available for your layout are all in dp
+units—remember that your layout dimensions should always be defined using dp units,
+because what you care about is the amount of space available after the system accounts for screen
+density (as opposed to using raw pixel numbers). The different resource configurations that you can
+specify based on the space available for your layout are summarized in table 2. When building an
+application for Android 3.2 and higher, you should use these new qualifiers instead of those for the
+traditional screen size groups (small, normal, large, and xlarge).
+
+Note: The sizes that you specify using these qualifiers are
+not the actual screen sizes. Rather, the sizes are for the width or height in dp
+units that are available to your activity's window. The Android system
+might use some of the screen for system UI (such as the system bar at the bottom of the screen or
+the status bar at the top), so some of the screen might not be available for your layout. Thus, the
+sizes you declare should be specifically about the sizes needed by your activity—the system
+accounts for any space used by system UI when declaring how much space it provides for your layout.
+Also beware that the Action Bar is considered
+a part of your application's window space, although your layout does not declare it, so it reduces
+the space available for your layout and you must account for it in your design.
+
+Table 2. New configuration qualifers for screen size
+(introduced in Android 3.2).
+
+ | Screen configuration | Qualifier values | Description |
|---|
+ | Smallest available width |
+ sw<N>dp
+ Examples:
+ sw600dp
+ sw720dp
+ |
+
+ Specifies the "smallest width" in dp units that must be available to your
+application in order for the resources to be used—defined by the <N>
+value—regardless of the screen's current orientation.
+For example, if your layout requires that its shortest side be at least 600 dp in length at all
+times, then you can put your layout files in res/layout-sw600dp/ and
+the system will use them only when the shortest side of available screen space it at least
+600dp.
+ This is the most important size configuration value, because it replaces the old screen size
+buckets with a discrete number that specifies the effective size available for your UI. This number
+is based on width because that is most often the driving factor in designing a layout. A UI will
+often scroll vertically, but have fairly hard constraints on the minimum space it needs
+horizontally. The available width is also the key factor in determining whether to use a one-pane
+layout for handsets or multi-pane layout for tablets.
+ |
+
+
+ | Available width |
+ w<N>dp
+ Examples:
+ w720dp
+ w1024dp
+ |
+
+ Specifies a minimum available width in dp units at which the resources should be
+used—defined by the <N> value. The system's corresponding value for the
+width changes when the screen's orientation switches between landscape and portrait to
+reflect the current actual width that's available for your UI.
+ This is often useful to determine whether to use a multi-pane layout, because even on a
+tablet device, you often won't want the same multi-pane layout for portrait orientation as you do
+for landscape. Thus, you can use this to specify the minimum width required for the layout, instead
+of using both the screen size and orientation qualifiers together.
+ |
+
+
+ | Available height |
+ h<N>dp
+ Examples:
+ h720dp
+ h1024dp
+ etc.
+ |
+
+ Specifies a minimum screen height in dp units at which the resources should be
+used—defined by the <N> value. The system's corresponding value for
+the height changes when the screen's orientation switches between landscape and portrait to
+reflect the current actual height that's available for your UI.
+ Using this to define the
+height required by your layout is useful in the same way as w<N>dp is for
+defining the required width, instead of using both the screen size and orientation qualifiers.
+However, most apps won't need this qualifier, considering that UIs often scroll vertically and are
+thus more flexible with how much height is available, whereas the width is more rigid.
+ |
+
+
+
+While using these qualifiers might seem more complicated than using screen size groups, it should
+actually be simpler once you determine the requirements for your UI. When you design your UI,
+the main thing you probably care about is the actual size at which your application switches between
+a handset-style UI and a tablet-style UI that uses multiple panes. The exact point of this switch
+will depend on your particular design—maybe you need a 720dp width for your tablet layout,
+maybe 600dp is enough, or 480dp, or some number between these. Using these qualifiers in table 2,
+you are in control of the precise size at which your layout changes.
+
+
+Configuration examples
+
+To help you target some of your designs for different types of devices, here are some
+numbers for typical screen widths:
+
+
+ - 320dp: a typical phone screen (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).
+ - 480dp: a tweener tablet like the Streak (480x800 mdpi).
+ - 600dp: a 7” tablet (600x1024 mdpi).
+ - 720dp: a 10” tablet (720x1280 mdpi, 800x1280 mdpi, etc).
+
+
+Using the size qualifiers from table 2, your application can switch between your different layout
+resources for handsets and tablets using any number you want for width and/or height. For example,
+if 600dp is the smallest available width supported by your tablet layout, you can provide these two
+sets of layouts:
+
+
+res/layout/main_activity.xml # For handsets
+res/layout-sw600dp/main_activity.xml # For tablets
+
+
+In this case, the smallest width of the available screen space must be 600dp in order for the
+tablet layout to be applied.
+
+For other cases in which you want to further customize your UI to differentiate between sizes
+such as 7” and 10” tablets, you can define additional smallest width layouts:
+
+
+res/layout/main_activity.xml # For handsets (smaller than 600dp available width)
+res/layout-sw600dp/main_activity.xml # For 7” tablets (600dp wide and bigger)
+res/layout-sw720dp/main_activity.xml # For 10” tablets (720dp wide and bigger)
+
+
+Notice that the previous two sets of example resources use the "smallest width" qualifer, {@code
+sw<N>dp}, which specifies the smallest of the screen's two sides, regardless of the
+device's current orientation. Thus, using {@code sw<N>dp} is a simple way to specify the
+overall screen size available for your layout by ignoring the screen's orientation.
+
+However, in some cases, what might be
+important for your layout is exactly how much width or height is currently available. For
+example, if you have a two-pane layout with two fragments side by side, you might want to use it
+whenever the screen provides at least 600dp of width, whether the device is in landscape or
+portrait orientation. In this case, your resources might look like this:
+
+
+res/layout/main_activity.xml # For handsets (smaller than 600dp available width)
+res/layout-w600dp/main_activity.xml # Multi-pane (any screen with 600dp available width or more)
+
+
+Notice that the second set is using the "available width" qualifier, {@code w<N>dp}. This
+way, one device may actually use both layouts, depending on the orientation of the screen (if
+the available width is at least 600dp in one orientation and less than 600dp in the other
+orientation).
+
+If the available height is a concern for you, then you can do the same using the {@code
+h<N>dp} qualifier. Or, even combine the {@code w<N>dp} and {@code h<N>dp}
+qualifiers if you need to be really specific.
+
+
+Declaring screen size support
+
+Once you've implemented your layouts for different screen sizes, it's equally important that you
+declare in your manifest file which screens your application supports.
+
+Along with the new configuration qualifiers for screen size, Android 3.2 introduces new
+attributes for the <supports-screens>
+manifest element:
+
+
+
+
+ -
+{@code android:compatibleWidthLimitDp}
+ - This attribute allows you to enable screen compatibility mode as a
+user-optional feature by specifying the maximum "smallest width" that your application
+supports. If the smallest side of a device's available screen is greater than your value here,
+users can still install your application, but are offered to run it in screen compatibility mode. By
+default, screen compatibility mode is disabled and your layout is resized to fit the screen as
+usual, but a button is available in the system bar that allows users to toggle screen compatibility
+mode on and off.
+
Note: If your application's layout properly resizes for large
+screens, you do not need to use this attribute. We recommend that you avoid using this
+attribute and instead ensure your layout resizes for larger screens by following the
+recommendations in this document.
+
+ -
+{@code android:largestWidthLimitDp}
+ - This attribute allows you to force-enable screen compatibility mode by specifying
+the maximum "smallest width" that your application supports. If the smallest
+side of a device's available screen is greater than your value here, the application runs in screen
+compatibility mode with no way for the user to disable it.
+
Note: If your application's layout properly resizes for large
+screens, you do not need to use this attribute. We recommend that you avoid using this
+attribute and instead ensure your layout resizes for larger screens by following the
+recommendations in this document.
+
+
+Caution: When developing for Android 3.2 and higher, you
+should not use the older screen size attributes in combination with the attributes
+listed above. Using both the new attributes and the older size attributes might cause
+unexpected behavior.
+
+For more information about each of these attributes, follow the respective links above.
+
+
+
+
Best Practices
The objective of supporting multiple screens is to create an application that can function
@@ -875,7 +1200,7 @@ SDK Manager.exe} from your Android SDK directory (on Windows only) or execute {@
the {@code <sdk>/tools/} directory (on all platforms). Figure 6 shows the Android SDK and
AVD Manager with a selection of AVDs, for testing various screen configurations.
-Table 2 shows the various emulator skins that are available in the Android SDK, which you can use
+
Table 3 shows the various emulator skins that are available in the Android SDK, which you can use
to emulate some of the most common screen configurations.
For more information about creating and using AVDs to test your application, see Managing AVDs with
Manager.
-Table 2. Various screen
+
Table 3. Various screen
configurations available from emulator skins in the Android SDK (indicated in bold) and other
representative resolutions.
diff --git a/docs/html/guide/topics/manifest/supports-screens-element.jd b/docs/html/guide/topics/manifest/supports-screens-element.jd
index 605a2bb482e14..a659678112885 100644
--- a/docs/html/guide/topics/manifest/supports-screens-element.jd
+++ b/docs/html/guide/topics/manifest/supports-screens-element.jd
@@ -8,15 +8,15 @@ parent.link=manifest-intro.html
syntax:
-<supports-screens android:requiresSmallestWidthDp="integer"
- android:compatibleWidthLimitDp="integer"
- android:largestWidthLimitDp="integer"
- android:resizeable=["true"| "false"]
+<supports-screens android:resizeable=["true"| "false"]
android:smallScreens=["true" | "false"]
android:normalScreens=["true" | "false"]
android:largeScreens=["true" | "false"]
android:xlargeScreens=["true" | "false"]
- android:anyDensity=["true" | "false"] />
+ android:anyDensity=["true" | "false"]
+ android:requiresSmallestWidthDp="integer"
+ android:compatibleWidthLimitDp="integer"
+ android:largestWidthLimitDp="integer"/>
@@ -24,37 +24,38 @@ parent.link=manifest-intro.html
<manifest>
description:
-Lets you specify the screen sizes your application supports and enable screen
-compatibility mode for screens larger than what your application supports. By default, a modern
-application (using API Level 4 or higher) supports all screen sizes; older applications are assumed
-to support only the "normal" screen size. Screen size is determined by the number of pixels on the
-screen after the system accounts for screen density scaling.
+Lets you specify the screen sizes your application supports and enable screen compatibility mode for screens
+larger than what your application supports. It's important that you always use this element in your
+application to specify the screen sizes your application supports.
An application "supports" a given screen size if it resizes properly to fill the entire screen.
-By default, the system resizes your application UI to fill the screen if you have set
-either {@code
-minSdkVersion} or {@code
-targetSdkVersion} to {@code "4"} or higher. Normal resizing works well for most applications and
-you don't have to do any extra work to make your application work on screens larger than a
-handset device.
-
-In addition to allowing the system to resize your application to fit the current screen, you can
-optimize your UI for different screen sizes by providing alternative
-layout resources for different sizes. For instance, you might want to modify the layout
-of an activity when it is on a tablet or similar device that has an xlarge screen.
+layout resources. For instance, you might want to modify the layout of an activity
+when it is on a tablet compared to when running on a handset device.
-However, if your application does not work well when resized to fit different screen sizes,
-you can use the attributes of the {@code <supports-screens>} element to control whether
-your application should be distributed to smaller screens or have its UI scaled up to fit larger
-screens using the system's screen compatibility mode. When you have not designed for larger screen
-sizes and the normal resizing does not achieve the appropriate results, screen compatibility
-mode will scale your UI by emulating a normal size screen and then zooming in on it so
-that it fills the entire screen—thus achieving the same layout as a normal handset device on
-the large screen (but this usually causes pixelation and blurring of your UI).
+However, if your application does not work well when resized to fit different screen sizes, you
+can use the attributes of the {@code <supports-screens>} element to control whether your
+application should be distributed to smaller screens or have its UI scaled up ("zoomed") to fit
+larger screens using the system's screen compatibility mode. When you
+have not designed for larger screen sizes and the normal resizing does not achieve the appropriate
+results, screen compatibility mode will scale your UI by emulating a normal size
+screen and medium density, then zooming in so that it fills the entire screen. Beware that this
+causes pixelation and blurring of your UI, so it's better if you optimize your UI for large
+screens.
+
+Note: Android 3.2 introduces new attributes: {@code
+android:requiresSmallestWidthDp}, {@code android:compatibleWidthLimitDp}, and {@code
+android:largestWidthLimitDp}. If you're developing your application for Android 3.2 and higher,
+you should use these attributes to declare your screen size support, instead of the attributes
+based on generalized screen sizes.
For more information about how to properly support different screen sizes so that you can avoid
-using screen compatibility mode, read
+using screen compatibility mode with your application, read
Supporting Multiple Screens.
@@ -62,12 +63,87 @@ using screen compatibility mode, read
+
+ - {@code android:resizeable}
+ - Indicates whether the application is resizeable for different screen sizes. This attribute is
+true, by default. If set false, the system will run your application in screen compatibility mode on large
+screens.
+
+
This attribute is deprecated. It was introduced to help applications
+transition from Android 1.5 to 1.6, when support for multiple screens was first introduced. You
+should not use it.
+
+
+ - {@code android:smallScreens}
+ - Indicates whether the application supports smaller screen form-factors.
+ A small screen is defined as one with a smaller aspect ratio than
+ the "normal" (traditional HVGA) screen. An application that does
+ not support small screens will not be available for
+ small screen devices from external services (such as Android Market), because there is little
+the platform can do to make such an application work on a smaller screen. This is {@code "true"} by
+default.
+
+
+ - {@code android:normalScreens}
+ - Indicates whether an application supports the "normal" screen
+ form-factors. Traditionally this is an HVGA medium density
+ screen, but WQVGA low density and WVGA high density are also
+ considered to be normal. This attribute is "true" by default.
+
+
+ - {@code android:largeScreens}
+ - Indicates whether the application supports larger screen form-factors.
+ A large screen is defined as a screen that is significantly larger
+ than a "normal" handset screen, and thus might require some special care
+ on the application's part to make good use of it, though it may rely on resizing by the
+system to fill the screen.
+
The default value for this actually varies between some versions, so it's better if
+you explicitly declare this attribute at all times. Beware that setting it "false" will
+generally enable screen
+compatibility mode.
+
+
+ - {@code android:xlargeScreens}
+ - Indicates whether the application supports extra large screen form-factors.
+ An xlarge screen is defined as a screen that is significantly larger
+ than a "large" screen, such as a tablet (or something larger) and may require special care
+ on the application's part to make good use of it, though it may rely on resizing by the
+system to fill the screen.
+
The default value for this actually varies between some versions, so it's better if
+you explicitly declare this attribute at all times. Beware that setting it "false" will
+generally enable screen
+compatibility mode.
+ This attribute was introduced in API level 9.
+
+
+ - {@code android:anyDensity}
+ - Indicates whether the application includes resources to accommodate any screen
+ density.
+
For applications that support Android 1.6 (API level 4) and higher, this is "true"
+by default and you should not set it "false" unless you're absolutely certain that
+it's necessary for your application to work. The only time it might be necessary to disable this
+is if your app directly manipulates bitmaps (see the Supporting Multiple
+Screens document for more information).
+
- {@code android:requiresSmallestWidthDp}
- This attribute specifies the minimum "smallest screen width" with which your
application is compatible. In order for a device to be considered compatible with your
application, the shortest side of the available screen space must be equal to or greater than this
value.
+
+
Caution: The Android system does not pay attention to this
+attribute, so it does not affect how your application behaves at runtime. Instead, it is used
+to enable filtering for your application on services such as Android Market. However,
+Android Market currently does not support this attribute (on Android 3.2), so you
+should continue using the other size attributes if your application does not support
+small screens.
+
+
This attribute was introduced in API level 13.
- {@code android:compatibleWidthLimitDp}
- - This attribute allows you to enable screen compatibility mode as a user-optional feature by
-specifying the maximum "smallest screen width" for which your application is designed. If the value
-you supply here is less than the shortest side of the available screen space, users can still
-install your application, but are offered to run it in screen compatibility mode. By default, screen
-compatibility mode is disabled and your layout is resized to fit the screen as usual, but a
-button is available in the system bar that allows the user to toggle screen compatibility mode on
-and off.
+
- This attribute allows you to enable screen compatibility mode as a
+user-optional feature by specifying the maximum "smallest screen width" for which your application
+is designed. If the smallest side of a device's available screen is greater than your value here,
+users can still install your application, but are offered to run it in screen compatibility mode. By
+default, screen compatibility mode is disabled and your layout is resized to fit the screen as
+usual, but a button is available in the system bar that allows the user to toggle screen
+compatibility mode on and off.
If your application is compatible with all screen sizes and its layout properly resizes, you do
not need to use this attribute.
- Note: Currently, screen compatibility mode only emulates handset
+
Note: Currently, screen compatibility mode emulates only handset
screens with a 320dp width, so screen compatibility mode is not applied if your value for {@code
android:compatibleWidthLimitDp} is larger than 320.
This attribute was introduced in API level 13.
- {@code android:largestWidthLimitDp}
- - This attribute allows you to force enable screen compatibility mode by specifying the maximum
-"smallest screen width" for which your application is designed. If the value you supply here is less
-than the shortest side of the available screen space, the application runs in screen
+
- This attribute allows you to force-enable screen compatibility mode by specifying
+the maximum "smallest screen width" for which your application is designed. If the smallest side of
+a device's available screen is greater than your value here, the application runs in screen
compatibility mode with no way for the user to disable it.
If your application is compatible with all screen sizes and its layout properly resizes, you do
not need to use this attribute. Otherwise, you should first consider using the {@code android:compatibleWidthLimitDp} attribute. Yo
{@code android:largestWidthLimitDp} attribute only when your application is functionally broken when
resized for larger screens and screen compatibility mode is the only way that users should use
your application.
- Note: Currently, screen compatibility mode only emulates handset
+
Note: Currently, screen compatibility mode emulates only handset
screens with a 320dp width, so screen compatibility mode is not applied if your value for {@code
android:largestWidthLimitDp} is larger than 320.
This attribute was introduced in API level 13.
-
- - {@code android:resizeable}
- - Indicates whether the application is resizeable for different screen sizes. This attribute is
-true, by default, if you have set either {@code minSdkVersion} or {@code targetSdkVersion} to
-{@code "4"} or higher. Otherwise, it is false by default. If set false, the system will not resize
-your application when run on large or xlarge screens. Instead, the
-application appears in a "postage stamp" that equals the normal screen size that your
-application does support. This is less than an ideal experience for users, because the
-application appears smaller than the available screen, but it might help your application run
-normally if it were designed only for the normal screen size and some behaviors do not work
-when resized.
-
To provide the best experience on all screen sizes, you should allow resizing and, if your
-application does not work well on larger screens, follow the guide to Supporting Multiple Screens to enable
-additional screen support.
- This attribute is deprecated as of API level 13.
-
-
-
- - {@code android:smallScreens}
- - Indicates whether the application supports smaller screen form-factors.
- A small screen is defined as one with a smaller aspect ratio than
- the "normal" (traditional HVGA) screen. An application that does
- not support small screens will not be available for
- small screen devices from external services (such as Android Market), because there is little
-the platform can do
- to make such an application work on a smaller screen. If the application has set either {@code minSdkVersion} or {@code targetSdkVersion} to
-{@code "4"} or higher,
-the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to
-{@code "false"}.
-
This attribute is deprecated as of API level 13.
-
-
- - {@code android:normalScreens}
- - Indicates whether an application supports the "normal" screen
- form-factors. Traditionally this is an HVGA medium density
- screen, but WQVGA low density and WVGA high density are also
- considered to be normal. This attribute is "true" by default,
- and applications currently should leave it that way.
-
This attribute is deprecated as of API level 13.
-
-
- - {@code android:largeScreens}
- - Indicates whether the application supports larger screen form-factors.
- A large screen is defined as a screen that is significantly larger
- than a "normal" handset screen, and thus might require some special care
- on the application's part to make good use of it, though it may rely on resizing by the
-system to fill the screen. If the application has set either {@code minSdkVersion} or {@code targetSdkVersion} to
-{@code "4"} or higher,
-the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to
-{@code "false"}.
-
This attribute is deprecated as of API level 13.
-
-
- - {@code android:xlargeScreens}
- - Indicates whether the application supports extra large screen form-factors.
- An xlarge screen is defined as a screen that is significantly larger
- than a "large" screen, such as a tablet (or something larger) and may require special care
- on the application's part to make good use of it, though it may rely on resizing by the
-system to fill the screen. If the application has set either {@code minSdkVersion} or {@code targetSdkVersion} to
-{@code "4"} or higher,
-the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to
-{@code "false"}.
-
This attribute was introduced in API level 9.
- This attribute is deprecated as of API level 13.
-
-
- - {@code android:anyDensity}
- - Indicates whether the application includes resources to accommodate any screen
- density. Older applications (before API Level 4) are assumed unable to
- accomodate all densities and this is {@code "false"} by default. If the application has set
-either {@code minSdkVersion} or {@code targetSdkVersion} to
-{@code "4"} or higher,
-the default value for this is {@code "true"}. Otherwise, it is {@code "false"}.
- You can explicitly supply your abilities here.
-
Based on the "standard" device screen density (medium dpi), the Android framework will scale
-down application assets by a factor of 0.75 (low dpi screens) or scale them up by a factor of 1.5
-(high dpi screens), when you don't provide alternative resources for a specifc screen density. The
-screen density is expressed as dots-per-inch (dpi).
- This attribute is deprecated as of API level 13.
-
diff --git a/docs/html/guide/topics/resources/providing-resources.jd b/docs/html/guide/topics/resources/providing-resources.jd
index ea778c1deb6ed..ceff85125810b 100644
--- a/docs/html/guide/topics/resources/providing-resources.jd
+++ b/docs/html/guide/topics/resources/providing-resources.jd
@@ -334,7 +334,7 @@ indicates the current locale.
- | Smallest screen width |
+ Smallest available width |
sw<N>dp
Examples:
sw320dp
@@ -381,7 +381,7 @@ indicates the current locale.
|
- | Screen width |
+ Available width |
w<N>dp
Examples:
w720dp
@@ -389,7 +389,7 @@ indicates the current locale.
etc.
|
- Specifies a minimum screen width, in {@code dp} units at which the resource
+ Specifies a minimum available screen width, in {@code dp} units at which the resource
should be used—defined by the <N> value. This
configuration value will change when the orientation
changes between landscape and portrait to match the current actual width.
@@ -406,7 +406,7 @@ indicates the current locale.
|
- | Screen height |
+ Available height |
h<N>dp
Examples:
h720dp
@@ -414,7 +414,7 @@ indicates the current locale.
etc.
|
- Specifies a minimum screen height, in "dp" units at which the resource
+ Specifies a minimum available screen height, in "dp" units at which the resource
should be used—defined by the <N> value. This
configuration value will change when the orientation
changes between landscape and portrait to match the current actual height.
|
+
+
+
+
+
-