Merge change 8126 into donut

* changes:
  First pass at reworking screen density/size APIs.

5 files changed, 162 insertions, 68 deletions

diff --git a/core/java/android/content/pm/ApplicationInfo.java b/core/java/android/content/pm/ApplicationInfo.java
index 28a77a5..4a3137f 100644
--- a/core/java/android/content/pm/ApplicationInfo.java
+++ b/core/java/android/content/pm/ApplicationInfo.java
@@ -161,12 +161,20 @@ public class ApplicationInfo extends PackageItemInfo implements Parcelable {
     public static final int FLAG_SUPPORTS_LARGE_SCREENS = 1<<11;
     
     /**
+     * Value for {@link #flags}: true when the application knows how to adjust
+     * its UI for different screen sizes.  Corresponds to
+     * {@link android.R.styleable#AndroidManifestSupportsScreens_resizeable
+     * android:resizeable}.
+     */
+    public static final int FLAG_RESIZEABLE_FOR_SCREENS = 1<<12;
+    
+    /**
      * Value for {@link #flags}: this is false if the application has set
      * its android:allowBackup to false, true otherwise.
      * 
      * {@hide}
      */
-    public static final int FLAG_ALLOW_BACKUP = 1<<12;
+    public static final int FLAG_ALLOW_BACKUP = 1<<13;
     
     /**
      * Indicates that the application supports any densities;
@@ -183,7 +191,7 @@ public class ApplicationInfo extends PackageItemInfo implements Parcelable {
      * {@link #FLAG_ALLOW_CLEAR_USER_DATA}, {@link #FLAG_UPDATED_SYSTEM_APP},
      * {@link #FLAG_TEST_ONLY}, {@link #FLAG_SUPPORTS_SMALL_SCREENS},
      * {@link #FLAG_SUPPORTS_NORMAL_SCREENS},
-     * {@link #FLAG_SUPPORTS_LARGE_SCREENS}.
+     * {@link #FLAG_SUPPORTS_LARGE_SCREENS}, {@link #FLAG_RESIZEABLE_FOR_SCREENS}.
      */
     public int flags = 0;
     
@@ -400,7 +408,7 @@ public class ApplicationInfo extends PackageItemInfo implements Parcelable {
      */
     public void disableCompatibilityMode() {
         flags |= (FLAG_SUPPORTS_LARGE_SCREENS | FLAG_SUPPORTS_NORMAL_SCREENS |
-                FLAG_SUPPORTS_SMALL_SCREENS);
+                FLAG_SUPPORTS_SMALL_SCREENS | FLAG_RESIZEABLE_FOR_SCREENS);
         supportsDensities = ANY_DENSITIES_ARRAY;
     }
 }
diff --git a/core/java/android/content/pm/PackageParser.java b/core/java/android/content/pm/PackageParser.java
index 39c27aa..93ba959 100644
--- a/core/java/android/content/pm/PackageParser.java
+++ b/core/java/android/content/pm/PackageParser.java
@@ -674,6 +674,7 @@ public class PackageParser {
         int supportsSmallScreens = 1;
         int supportsNormalScreens = 1;
         int supportsLargeScreens = 1;
+        int resizeable = 1;
         
         int outerDepth = parser.getDepth();
         while ((type=parser.next()) != parser.END_DOCUMENT
@@ -883,6 +884,9 @@ public class PackageParser {
                 supportsLargeScreens = sa.getInteger(
                         com.android.internal.R.styleable.AndroidManifestSupportsScreens_largeScreens,
                         supportsLargeScreens);
+                resizeable = sa.getInteger(
+                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_resizeable,
+                        supportsLargeScreens);
 
                 sa.recycle();
                 
@@ -969,6 +973,11 @@ public class PackageParser {
                         >= android.os.Build.VERSION_CODES.CUR_DEVELOPMENT)) {
             pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS;
         }
+        if (resizeable < 0 || (resizeable > 0
+                && pkg.applicationInfo.targetSdkVersion
+                        >= android.os.Build.VERSION_CODES.CUR_DEVELOPMENT)) {
+            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS;
+        }
         int densities[] = null;
         int size = pkg.supportsDensityList.size();
         if (size > 0) {
diff --git a/core/java/android/content/res/CompatibilityInfo.java b/core/java/android/content/res/CompatibilityInfo.java
index 2805bd5..517551e 100644
--- a/core/java/android/content/res/CompatibilityInfo.java
+++ b/core/java/android/content/res/CompatibilityInfo.java
@@ -69,8 +69,8 @@ public class CompatibilityInfo {
     /**
      * A flag mask to indicates that the application can expand over the original size.
      * The flag is set to true if
-     * 1) Application declares its expandable in manifest file using <expandable /> or
-     * 2) The screen size is same as (320 x 480) * density. 
+     * 1) Application declares its expandable in manifest file using <supports-screens> or
+     * 2) Configuration.SCREENLAYOUT_COMPAT_NEEDED is not set
      * {@see compatibilityFlag}
      */
     private static final int EXPANDABLE = 2;
@@ -78,11 +78,28 @@ public class CompatibilityInfo {
     /**
      * A flag mask to tell if the application is configured to be expandable. This differs
      * from EXPANDABLE in that the application that is not expandable will be 
-     * marked as expandable if it runs in (320x 480) * density screen size.
+     * marked as expandable if Configuration.SCREENLAYOUT_COMPAT_NEEDED is not set.
      */
     private static final int CONFIGURED_EXPANDABLE = 4; 
 
-    private static final int SCALING_EXPANDABLE_MASK = SCALING_REQUIRED | EXPANDABLE;
+    /**
+     * A flag mask to indicates that the application supports large screens.
+     * The flag is set to true if
+     * 1) Application declares it supports large screens in manifest file using <supports-screens> or
+     * 2) The screen size is not large
+     * {@see compatibilityFlag}
+     */
+    private static final int LARGE_SCREENS = 8;
+    
+    /**
+     * A flag mask to tell if the application supports large screens. This differs
+     * from LARGE_SCREENS in that the application that does not support large
+     * screens will be marked as supporting them if the current screen is not
+     * large.
+     */
+    private static final int CONFIGURED_LARGE_SCREENS = 16; 
+
+    private static final int SCALING_EXPANDABLE_MASK = SCALING_REQUIRED | EXPANDABLE | LARGE_SCREENS;
 
     /**
      * The effective screen density we have selected for this application.
@@ -108,7 +125,10 @@ public class CompatibilityInfo {
         appFlags = appInfo.flags;
         
         if ((appInfo.flags & ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS) != 0) {
-            mCompatibilityFlags = EXPANDABLE | CONFIGURED_EXPANDABLE;
+            mCompatibilityFlags |= LARGE_SCREENS | CONFIGURED_LARGE_SCREENS;
+        }
+        if ((appInfo.flags & ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS) != 0) {
+            mCompatibilityFlags |= EXPANDABLE | CONFIGURED_EXPANDABLE;
         }
         
         float packageDensityScale = -1.0f;
@@ -162,7 +182,8 @@ public class CompatibilityInfo {
     private CompatibilityInfo() {
         this(ApplicationInfo.FLAG_SUPPORTS_SMALL_SCREENS
                 | ApplicationInfo.FLAG_SUPPORTS_NORMAL_SCREENS
-                | ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS,
+                | ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS
+                | ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS,
                 EXPANDABLE | CONFIGURED_EXPANDABLE,
                 DisplayMetrics.DENSITY_DEVICE,
                 1.0f,
@@ -190,6 +211,17 @@ public class CompatibilityInfo {
     }
 
     /**
+     * Sets large screen bit in the compatibility flag.
+     */
+    public void setLargeScreens(boolean expandable) {
+        if (expandable) {
+            mCompatibilityFlags |= CompatibilityInfo.LARGE_SCREENS;
+        } else {
+            mCompatibilityFlags &= ~CompatibilityInfo.LARGE_SCREENS;
+        }
+    }
+
+    /**
      * @return true if the application is configured to be expandable.
      */
     public boolean isConfiguredExpandable() {
@@ -197,6 +229,13 @@ public class CompatibilityInfo {
     }
 
     /**
+     * @return true if the application is configured to be expandable.
+     */
+    public boolean isConfiguredLargeScreens() {
+        return (mCompatibilityFlags & CompatibilityInfo.CONFIGURED_LARGE_SCREENS) != 0;
+    }
+
+    /**
      * @return true if the scaling is required
      */
     public boolean isScalingRequired() {
@@ -204,7 +243,8 @@ public class CompatibilityInfo {
     }
     
     public boolean supportsScreen() {
-        return (mCompatibilityFlags & CompatibilityInfo.EXPANDABLE) != 0;
+        return (mCompatibilityFlags & (EXPANDABLE|LARGE_SCREENS))
+                == (EXPANDABLE|LARGE_SCREENS);
     }
     
     @Override
@@ -219,8 +259,8 @@ public class CompatibilityInfo {
      * @param params the window's parameter
      */
     public Translator getTranslator(WindowManager.LayoutParams params) {
-        if ( (mCompatibilityFlags & CompatibilityInfo.SCALING_EXPANDABLE_MASK)
-                == CompatibilityInfo.EXPANDABLE) {
+        if ( (mCompatibilityFlags & SCALING_EXPANDABLE_MASK)
+                == (EXPANDABLE|LARGE_SCREENS)) {
             if (DBG) Log.d(TAG, "no translation required");
             return null;
         }
diff --git a/core/java/android/content/res/Configuration.java b/core/java/android/content/res/Configuration.java
index 577aa60..5f44cc9 100644
--- a/core/java/android/content/res/Configuration.java
+++ b/core/java/android/content/res/Configuration.java
@@ -41,6 +41,39 @@ public final class Configuration implements Parcelable, Comparable<Configuration
      */
     public boolean userSetLocale;
 
+    public static final int SCREENLAYOUT_SIZE_MASK = 0x0f;
+    public static final int SCREENLAYOUT_SIZE_UNDEFINED = 0x00;
+    public static final int SCREENLAYOUT_SIZE_SMALL = 0x01;
+    public static final int SCREENLAYOUT_SIZE_NORMAL = 0x02;
+    public static final int SCREENLAYOUT_SIZE_LARGE = 0x03;
+    
+    public static final int SCREENLAYOUT_LONG_MASK = 0x30;
+    public static final int SCREENLAYOUT_LONG_UNDEFINED = 0x00;
+    public static final int SCREENLAYOUT_LONG_NO = 0x10;
+    public static final int SCREENLAYOUT_LONG_YES = 0x20;
+    
+    /**
+     * Special flag we generate to indicate that the screen layout requires
+     * us to use a compatibility mode for apps that are not modern layout
+     * aware.
+     * @hide
+     */
+    public static final int SCREENLAYOUT_COMPAT_NEEDED = 0x10000000;
+    
+    /**
+     * Bit mask of overall layout of the screen.  Currently there are two
+     * fields:
+     * <p>The {@link #SCREENLAYOUT_SIZE_MASK} bits define the overall size
+     * of the screen.  They may be one of
+     * {@link #SCREENLAYOUT_SIZE_SMALL}, {@link #SCREENLAYOUT_SIZE_NORMAL},
+     * or {@link #SCREENLAYOUT_SIZE_LARGE}.
+     * 
+     * <p>The {@link #SCREENLAYOUT_LONG_MASK} defines whether the screen
+     * is wider/taller than normal.  They may be one of
+     * {@link #SCREENLAYOUT_LONG_NO} or {@link #SCREENLAYOUT_LONG_YES}.
+     */
+    public int screenLayout;
+    
     public static final int TOUCHSCREEN_UNDEFINED = 0;
     public static final int TOUCHSCREEN_NOTOUCH = 1;
     public static final int TOUCHSCREEN_STYLUS = 2;
@@ -116,18 +149,6 @@ public final class Configuration implements Parcelable, Comparable<Configuration
      */
     public int orientation;
     
-    public static final int SCREENLAYOUT_UNDEFINED = 0;
-    public static final int SCREENLAYOUT_SMALL = 1;
-    public static final int SCREENLAYOUT_NORMAL = 2;
-    public static final int SCREENLAYOUT_LARGE = 3;
-    
-    /**
-     * Overall layout of the screen.  May be one of
-     * {@link #SCREENLAYOUT_SMALL}, {@link #SCREENLAYOUT_NORMAL},
-     * or {@link #SCREENLAYOUT_LARGE}.
-     */
-    public int screenLayout;
-    
     /**
      * Construct an invalid Configuration.  You must call {@link #setToDefaults}
      * for this object to be valid.  {@more}
@@ -198,7 +219,7 @@ public final class Configuration implements Parcelable, Comparable<Configuration
         hardKeyboardHidden = HARDKEYBOARDHIDDEN_UNDEFINED;
         navigation = NAVIGATION_UNDEFINED;
         orientation = ORIENTATION_UNDEFINED;
-        screenLayout = SCREENLAYOUT_UNDEFINED;
+        screenLayout = SCREENLAYOUT_SIZE_UNDEFINED;
     }
 
     /** {@hide} */
@@ -269,7 +290,7 @@ public final class Configuration implements Parcelable, Comparable<Configuration
             changed |= ActivityInfo.CONFIG_ORIENTATION;
             orientation = delta.orientation;
         }
-        if (delta.screenLayout != SCREENLAYOUT_UNDEFINED
+        if (delta.screenLayout != SCREENLAYOUT_SIZE_UNDEFINED
                 && screenLayout != delta.screenLayout) {
             changed |= ActivityInfo.CONFIG_SCREEN_LAYOUT;
             screenLayout = delta.screenLayout;
@@ -342,7 +363,7 @@ public final class Configuration implements Parcelable, Comparable<Configuration
                 && orientation != delta.orientation) {
             changed |= ActivityInfo.CONFIG_ORIENTATION;
         }
-        if (delta.screenLayout != SCREENLAYOUT_UNDEFINED
+        if (delta.screenLayout != SCREENLAYOUT_SIZE_UNDEFINED
                 && screenLayout != delta.screenLayout) {
             changed |= ActivityInfo.CONFIG_SCREEN_LAYOUT;
         }
diff --git a/core/java/android/util/DisplayMetrics.java b/core/java/android/util/DisplayMetrics.java
index 38d99b3..061f98a 100644
--- a/core/java/android/util/DisplayMetrics.java
+++ b/core/java/android/util/DisplayMetrics.java
@@ -123,51 +123,67 @@ public class DisplayMetrics {
      */
     public void updateMetrics(CompatibilityInfo compatibilityInfo, int orientation,
             int screenLayout) {
-        if (!compatibilityInfo.isConfiguredExpandable()) {
-            // Note: this assume that configuration is updated before calling
-            // updateMetrics method.
-            if (screenLayout == Configuration.SCREENLAYOUT_LARGE) {
-                // This is a large screen device and the app is not 
-                // compatible with large screens, to diddle it.
-                
+        boolean expandable = compatibilityInfo.isConfiguredExpandable();
+        boolean largeScreens = compatibilityInfo.isConfiguredLargeScreens();
+        
+        // Note: this assume that configuration is updated before calling
+        // updateMetrics method.
+        if (!expandable) {
+            if ((screenLayout&Configuration.SCREENLAYOUT_COMPAT_NEEDED) == 0) {
+                expandable = true;
+                // the current screen size is compatible with non-resizing apps.
+                compatibilityInfo.setExpandable(true);
+            } else {
                 compatibilityInfo.setExpandable(false);
-                // Figure out the compatibility width and height of the screen.
-                int defaultWidth;
-                int defaultHeight;
-                switch (orientation) {
-                    case Configuration.ORIENTATION_LANDSCAPE: {
-                        defaultWidth = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_HEIGHT * density +
-                                0.5f);
-                        defaultHeight = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_WIDTH * density +
-                                0.5f);
-                        break;
-                    }
-                    case Configuration.ORIENTATION_PORTRAIT:
-                    case Configuration.ORIENTATION_SQUARE:
-                    default: {
-                        defaultWidth = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_WIDTH * density +
-                                0.5f);
-                        defaultHeight = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_HEIGHT * density +
-                                0.5f);
-                        break;
-                    }
-                    case Configuration.ORIENTATION_UNDEFINED: {
-                        // don't change
-                        return;
-                    }
+            }
+        }
+        if (!largeScreens) {
+            if ((screenLayout&Configuration.SCREENLAYOUT_SIZE_MASK)
+                    != Configuration.SCREENLAYOUT_SIZE_LARGE) {
+                largeScreens = true;
+                // the current screen size is not large.
+                compatibilityInfo.setLargeScreens(true);
+            } else {
+                compatibilityInfo.setLargeScreens(false);
+            }
+        }
+        
+        if (!expandable || !largeScreens) {
+            // This is a larger screen device and the app is not 
+            // compatible with large screens, so diddle it.
+            
+            // Figure out the compatibility width and height of the screen.
+            int defaultWidth;
+            int defaultHeight;
+            switch (orientation) {
+                case Configuration.ORIENTATION_LANDSCAPE: {
+                    defaultWidth = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_HEIGHT * density +
+                            0.5f);
+                    defaultHeight = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_WIDTH * density +
+                            0.5f);
+                    break;
                 }
-                
-                if (defaultWidth < widthPixels) {
-                    // content/window's x offset in original pixels
-                    widthPixels = defaultWidth;
+                case Configuration.ORIENTATION_PORTRAIT:
+                case Configuration.ORIENTATION_SQUARE:
+                default: {
+                    defaultWidth = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_WIDTH * density +
+                            0.5f);
+                    defaultHeight = (int)(CompatibilityInfo.DEFAULT_PORTRAIT_HEIGHT * density +
+                            0.5f);
+                    break;
                 }
-                if (defaultHeight < heightPixels) {
-                    heightPixels = defaultHeight;
+                case Configuration.ORIENTATION_UNDEFINED: {
+                    // don't change
+                    return;
                 }
-                
-            } else {
-                // the screen size is same as expected size. make it expandable
-                compatibilityInfo.setExpandable(true);
+            }
+            
+            if (defaultWidth < widthPixels) {
+                // content/window's x offset in original pixels
+                widthPixels = defaultWidth;
+            }
+            if (defaultHeight < heightPixels) {
+                heightPixels = defaultHeight;
             }
         }
         if (compatibilityInfo.isScalingRequired()) {