From fe37f8f51d90fc4c6230e54dcd1270df5fcc6be3 Mon Sep 17 00:00:00 2001 From: Dianne Hackborn Date: Sun, 30 Sep 2012 12:24:33 -0700 Subject: Work on issue #6949468: android.dpi.cts.ConfigurationScreenLayoutTest... ...#testScreenLayout failures on JO This doesn't actually fix it; I have concluded that the test is broken (the platform is correctly reporting that this is a NOT LONG device because in portrait once you account for the status bar and system bar our size is 880dp high and 600dp wide, which is not enough for us to be in the LONG config). However while working on this I noticed that the code for computing the configuration of the external display was wrong. I have fixed that by putting this code for computing these parts of the configuration in a common place that both the window manager and external display code can use. Change-Id: Ic6a84b955e9ec345a87f725203a29e4712dac0ad --- core/java/android/app/ActivityThread.java | 14 +++-- core/java/android/content/res/Configuration.java | 72 +++++++++++++++++++++++- 2 files changed, 81 insertions(+), 5 deletions(-) (limited to 'core/java') diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java index 6638433..6ef3651 100644 --- a/core/java/android/app/ActivityThread.java +++ b/core/java/android/app/ActivityThread.java @@ -3872,14 +3872,20 @@ public final class ActivityThread { final void applyNonDefaultDisplayMetricsToConfigurationLocked( DisplayMetrics dm, Configuration config) { - config.screenLayout = Configuration.SCREENLAYOUT_SIZE_XLARGE - | Configuration.SCREENLAYOUT_LONG_NO; config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH; - config.orientation = (dm.widthPixels >= dm.heightPixels) ? - Configuration.ORIENTATION_LANDSCAPE : Configuration.ORIENTATION_PORTRAIT; config.densityDpi = dm.densityDpi; config.screenWidthDp = (int)(dm.widthPixels / dm.density); config.screenHeightDp = (int)(dm.heightPixels / dm.density); + int sl = Configuration.resetScreenLayout(config.screenLayout); + if (dm.widthPixels > dm.heightPixels) { + config.orientation = Configuration.ORIENTATION_LANDSCAPE; + config.screenLayout = Configuration.reduceScreenLayout(sl, + config.screenWidthDp, config.screenHeightDp); + } else { + config.orientation = Configuration.ORIENTATION_PORTRAIT; + config.screenLayout = Configuration.reduceScreenLayout(sl, + config.screenHeightDp, config.screenWidthDp); + } config.smallestScreenWidthDp = config.screenWidthDp; // assume screen does not rotate config.compatScreenWidthDp = config.screenWidthDp; config.compatScreenHeightDp = config.screenHeightDp; diff --git a/core/java/android/content/res/Configuration.java b/core/java/android/content/res/Configuration.java index 51b8d25..86d6ee7 100644 --- a/core/java/android/content/res/Configuration.java +++ b/core/java/android/content/res/Configuration.java @@ -172,7 +172,77 @@ public final class Configuration implements Parcelable, Comparable for more information. */ public int screenLayout; - + + /** @hide */ + static public int resetScreenLayout(int curLayout) { + return (curLayout&~(SCREENLAYOUT_LONG_MASK | SCREENLAYOUT_SIZE_MASK + | SCREENLAYOUT_COMPAT_NEEDED)) + | (SCREENLAYOUT_LONG_YES | SCREENLAYOUT_SIZE_XLARGE); + } + + /** @hide */ + static public int reduceScreenLayout(int curLayout, int longSizeDp, int shortSizeDp) { + int screenLayoutSize; + boolean screenLayoutLong; + boolean screenLayoutCompatNeeded; + + // These semi-magic numbers define our compatibility modes for + // applications with different screens. These are guarantees to + // app developers about the space they can expect for a particular + // configuration. DO NOT CHANGE! + if (longSizeDp < 470) { + // This is shorter than an HVGA normal density screen (which + // is 480 pixels on its long side). + screenLayoutSize = SCREENLAYOUT_SIZE_SMALL; + screenLayoutLong = false; + screenLayoutCompatNeeded = false; + } else { + // What size is this screen screen? + if (longSizeDp >= 960 && shortSizeDp >= 720) { + // 1.5xVGA or larger screens at medium density are the point + // at which we consider it to be an extra large screen. + screenLayoutSize = SCREENLAYOUT_SIZE_XLARGE; + } else if (longSizeDp >= 640 && shortSizeDp >= 480) { + // VGA or larger screens at medium density are the point + // at which we consider it to be a large screen. + screenLayoutSize = SCREENLAYOUT_SIZE_LARGE; + } else { + screenLayoutSize = SCREENLAYOUT_SIZE_NORMAL; + } + + // If this screen is wider than normal HVGA, or taller + // than FWVGA, then for old apps we want to run in size + // compatibility mode. + if (shortSizeDp > 321 || longSizeDp > 570) { + screenLayoutCompatNeeded = true; + } else { + screenLayoutCompatNeeded = false; + } + + // Is this a long screen? + if (((longSizeDp*3)/5) >= (shortSizeDp-1)) { + // Anything wider than WVGA (5:3) is considering to be long. + screenLayoutLong = true; + } else { + screenLayoutLong = false; + } + } + + // Now reduce the last screenLayout to not be better than what we + // have found. + if (!screenLayoutLong) { + curLayout = (curLayout&~SCREENLAYOUT_LONG_MASK) | SCREENLAYOUT_LONG_NO; + } + if (screenLayoutCompatNeeded) { + curLayout |= Configuration.SCREENLAYOUT_COMPAT_NEEDED; + } + int curSize = curLayout&SCREENLAYOUT_SIZE_MASK; + if (screenLayoutSize < curSize) { + curLayout = (curLayout&~SCREENLAYOUT_SIZE_MASK) | screenLayoutSize; + } + return curLayout; + } + /** * Check if the Configuration's current {@link #screenLayout} is at * least the given size. -- cgit v1.1