Merge "Allow mutable overlays to be enabled by default" into rvc-dev am: 214663924c

Change-Id: Ia9047a4ce072e122907bd1c12a1179afdbae5253

core/java/com/android/internal/content/om/OverlayConfig.java

@@ -21,7 +21,6 @@ import android.annotation.Nullable;
 import android.content.pm.PackagePartitions;
 import android.content.pm.parsing.ParsingPackageRead;
 import android.os.Build;
-import android.os.Process;
 import android.os.Trace;
 import android.util.ArrayMap;
 import android.util.Log;
@@ -232,20 +231,26 @@ public class OverlayConfig {
 
     /**
      * Returns whether the overlay is enabled by default.
-     * Overlays that are not configured are disabled by default mutable.
+     * Overlays that are not configured are disabled by default.
+     *
+     * If an immutable overlay has its enabled state change, the new enabled state is applied to the
+     * overlay.
+     *
+     * When a mutable is first seen by the OverlayManagerService, the default-enabled state will be
+     * applied to the overlay. If the configured default-enabled state changes in a subsequent boot,
+     * the default-enabled state will not be applied to the overlay.
+     *
+     * The configured enabled state will only be applied when:
+     * <ul>
+     * <li> The device is factory reset
+     * <li> The overlay is removed from the device and added back to the device in a future OTA
+     * <li> The overlay changes its package name
+     * <li> The overlay changes its target package name or target overlayable name
+     * <li> An immutable overlay becomes mutable
+     * </ul>
      */
     public boolean isEnabled(String packageName) {
         final Configuration config = mConfigurations.get(packageName);
-
-        // STOPSHIP(149499802): Enabling a mutable overlay currently has no effect. Either implement
-        // some behavior for default-enabled, mutable overlays or prevent parsing of the enabled
-        // attribute on overlays that are mutable.
-        if (config != null && config.parsedConfig.mutable) {
-            Log.w(TAG, "Default-enabled configuration for mutable overlay "
-                    + config.parsedConfig.packageName + " has no effect");
-            return OverlayConfigParser.DEFAULT_ENABLED_STATE;
-        }
-
         return config == null? OverlayConfigParser.DEFAULT_ENABLED_STATE
                 : config.parsedConfig.enabled;
     }

services/core/java/com/android/server/om/OverlayManagerServiceImpl.java

@@ -101,10 +101,6 @@ final class OverlayManagerServiceImpl {
             return true;
         }
 
-        if (getPackageConfiguredPriority(theTruth.packageName) != oldSettings.priority) {
-            return true;
-        }
-
         // If an immutable overlay changes its configured enabled state, reinitialize the overlay.
         if (!isMutable && isPackageConfiguredEnabled(theTruth.packageName)
                 != oldSettings.isEnabled()) {
@@ -160,6 +156,7 @@ final class OverlayManagerServiceImpl {
             final PackageInfo overlayPackage = overlayPackages.get(i);
             final OverlayInfo oi = storedOverlayInfos.get(overlayPackage.packageName);
 
+            int priority = getPackageConfiguredPriority(overlayPackage.packageName);
             if (mustReinitializeOverlay(overlayPackage, oi)) {
                 // if targetPackageName has changed the package that *used* to
                 // be the target must also update its assets
@@ -173,8 +170,10 @@ final class OverlayManagerServiceImpl {
                         overlayPackage.applicationInfo.getBaseCodePath(),
                         isPackageConfiguredMutable(overlayPackage.packageName),
                         isPackageConfiguredEnabled(overlayPackage.packageName),
-                        getPackageConfiguredPriority(overlayPackage.packageName),
+                        priority, overlayPackage.overlayCategory);
-                        overlayPackage.overlayCategory);
+            } else if (priority != oi.priority) {
+                mSettings.setPriority(overlayPackage.packageName, newUserId, priority);
+                packagesToUpdateAssets.add(oi.targetPackageName);
             }
 
             storedOverlayInfos.remove(overlayPackage.packageName);

services/core/java/com/android/server/om/OverlayManagerSettings.java

@@ -71,24 +71,9 @@ final class OverlayManagerSettings {
             @NonNull final String baseCodePath, boolean isMutable, boolean isEnabled, int priority,
             @Nullable String overlayCategory) {
         remove(packageName, userId);
-        final SettingsItem item =
+        insert(new SettingsItem(packageName, userId, targetPackageName, targetOverlayableName,
-                new SettingsItem(packageName, userId, targetPackageName, targetOverlayableName,
+                baseCodePath, OverlayInfo.STATE_UNKNOWN, isEnabled, isMutable, priority,
-                        baseCodePath, OverlayInfo.STATE_UNKNOWN, isEnabled, isMutable, priority,
+                overlayCategory));
-                        overlayCategory);
-
-        int i;
-        for (i = mItems.size() - 1; i >= 0; i--) {
-            SettingsItem parentItem = mItems.get(i);
-            if (parentItem.mPriority <= priority) {
-                break;
-            }
-        }
-        int pos = i + 1;
-        if (pos == mItems.size()) {
-            mItems.add(item);
-        } else {
-            mItems.add(pos, item);
-        }
     }
 
     /**
@@ -219,6 +204,21 @@ final class OverlayManagerSettings {
         return removed;
     }
 
+    /**
+     * Reassigns the priority of an overlay maintaining the values of the overlays other settings.
+     */
+    void setPriority(@NonNull final String packageName, final int userId, final int priority) {
+        final int moveIdx = select(packageName, userId);
+        if (moveIdx < 0) {
+            throw new BadKeyException(packageName, userId);
+        }
+
+        final SettingsItem itemToMove = mItems.get(moveIdx);
+        mItems.remove(moveIdx);
+        itemToMove.setPriority(priority);
+        insert(itemToMove);
+    }
+
     /**
      * Returns true if the settings were modified, false if they remain the same.
      */
@@ -284,6 +284,21 @@ final class OverlayManagerSettings {
         return true;
     }
 
+    /**
+     * Inserts the item into the list of settings items.
+     */
+    private void insert(@NonNull SettingsItem item) {
+        int i;
+        for (i = mItems.size() - 1; i >= 0; i--) {
+            SettingsItem parentItem = mItems.get(i);
+            if (parentItem.mPriority <= item.getPriority()) {
+                break;
+            }
+        }
+
+        mItems.add(i + 1, item);
+    }
+
     void dump(@NonNull final PrintWriter p, @NonNull DumpState dumpState) {
         // select items to display
         Stream<SettingsItem> items = mItems.stream();
@@ -583,6 +598,11 @@ final class OverlayManagerSettings {
             return mCache;
         }
 
+        private void setPriority(int priority) {
+            mPriority = priority;
+            invalidateCache();
+        }
+
         private void invalidateCache() {
             mCache = null;
         }

services/tests/servicestests/src/com/android/server/om/OverlayManagerServiceImplRebootTests.java

@@ -30,6 +30,7 @@ import org.junit.runner.RunWith;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.BiConsumer;
 
 @RunWith(AndroidJUnit4.class)
 public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceImplTestsBase {
@@ -132,57 +133,115 @@ public class OverlayManagerServiceImplRebootTests extends OverlayManagerServiceI
     }
 
     @Test
-    public void testMutabilityChange() {
+    public void testMutableEnabledToImmutableEnabled() {
         final OverlayManagerServiceImpl impl = getImpl();
         installTargetPackage(TARGET, USER);
 
-        addOverlayPackage(OVERLAY, TARGET, USER, false, true, 0);
+        final BiConsumer<Boolean, Boolean> setOverlay = (mutable, enabled) -> {
-        impl.updateOverlaysForUser(USER);
+            addOverlayPackage(OVERLAY, TARGET, USER, mutable, enabled, 0);
-        final OverlayInfo o1 = impl.getOverlayInfo(OVERLAY, USER);
+            impl.updateOverlaysForUser(USER);
-        assertNotNull(o1);
+            final OverlayInfo o1 = impl.getOverlayInfo(OVERLAY, USER);
-        assertTrue(o1.isEnabled());
+            assertNotNull(o1);
-        assertFalse(o1.isMutable);
+            assertEquals(enabled, o1.isEnabled());
+            assertEquals(mutable, o1.isMutable);
+        };
 
-        addOverlayPackage(OVERLAY, TARGET, USER, true, false, 0);
+        // Immutable/enabled -> mutable/enabled
-        impl.updateOverlaysForUser(USER);
+        setOverlay.accept(false /* mutable */, true /* enabled */);
-        final OverlayInfo o2 = impl.getOverlayInfo(OVERLAY, USER);
+        setOverlay.accept(true /* mutable */, true /* enabled */);
-        assertNotNull(o2);
-        assertFalse(o2.isEnabled());
-        assertTrue(o2.isMutable);
 
-        addOverlayPackage(OVERLAY, TARGET, USER, false, false, 0);
+        // Mutable/enabled -> immutable/enabled
-        impl.updateOverlaysForUser(USER);
+        setOverlay.accept(false /* mutable */, true /* enabled */);
-        final OverlayInfo o3 = impl.getOverlayInfo(OVERLAY, USER);
+
-        assertNotNull(o3);
+        // Immutable/enabled -> mutable/disabled
-        assertFalse(o3.isEnabled());
+        setOverlay.accept(true /* mutable */, false /* enabled */);
-        assertFalse(o3.isMutable);
+
+        // Mutable/disabled -> immutable/enabled
+        setOverlay.accept(false /* mutable */, true /* enabled */);
+
+        // Immutable/enabled -> immutable/disabled
+        setOverlay.accept(false /* mutable */, false /* enabled */);
+
+        // Immutable/disabled -> mutable/enabled
+        setOverlay.accept(true /* mutable */, true /* enabled */);
+
+        // Mutable/enabled -> immutable/disabled
+        setOverlay.accept(false /* mutable */, false /* enabled */);
+
+        // Immutable/disabled -> mutable/disabled
+        setOverlay.accept(true /* mutable */, false /* enabled */);
+
+        // Mutable/disabled -> immutable/disabled
+        setOverlay.accept(false /* mutable */, false /* enabled */);
     }
 
     @Test
-    public void testPriorityChange() {
+    public void testMutablePriorityChange() {
         final OverlayManagerServiceImpl impl = getImpl();
         installTargetPackage(TARGET, USER);
+        addOverlayPackage(OVERLAY, TARGET, USER, true, true, 0);
+        addOverlayPackage(OVERLAY2, TARGET, USER, true, true, 1);
+        impl.updateOverlaysForUser(USER);
 
+        final OverlayInfo o1 = impl.getOverlayInfo(OVERLAY, USER);
+        assertNotNull(o1);
+        assertEquals(0, o1.priority);
+
+        final OverlayInfo o2 = impl.getOverlayInfo(OVERLAY2, USER);
+        assertNotNull(o2);
+        assertEquals(1, o2.priority);
+
+        // Overlay priority changing between reboots should not affect enable state of mutable
+        // overlays
+        impl.setEnabled(OVERLAY, true, USER);
+
+        // Reorder the overlays
+        addOverlayPackage(OVERLAY, TARGET, USER, true, true, 1);
+        addOverlayPackage(OVERLAY2, TARGET, USER, true, true, 0);
+        impl.updateOverlaysForUser(USER);
+
+        final OverlayInfo o3 = impl.getOverlayInfo(OVERLAY, USER);
+        assertNotNull(o3);
+        assertEquals(1, o3.priority);
+
+        final OverlayInfo o4 = impl.getOverlayInfo(OVERLAY2, USER);
+        assertNotNull(o4);
+        assertEquals(0, o4.priority);
+        assertTrue(o1.isEnabled());
+    }
+
+    @Test
+    public void testImmutablePriorityChange() {
+        final OverlayManagerServiceImpl impl = getImpl();
+        installTargetPackage(TARGET, USER);
         addOverlayPackage(OVERLAY, TARGET, USER, false, true, 0);
         addOverlayPackage(OVERLAY2, TARGET, USER, false, true, 1);
         impl.updateOverlaysForUser(USER);
 
         final OverlayInfo o1 = impl.getOverlayInfo(OVERLAY, USER);
-        final OverlayInfo o2 = impl.getOverlayInfo(OVERLAY2, USER);
         assertNotNull(o1);
-        assertNotNull(o2);
         assertEquals(0, o1.priority);
+
+        final OverlayInfo o2 = impl.getOverlayInfo(OVERLAY2, USER);
+        assertNotNull(o2);
         assertEquals(1, o2.priority);
 
+        // Overlay priority changing between reboots should not affect enable state of mutable
+        // overlays
+        impl.setEnabled(OVERLAY, true, USER);
+
+        // Reorder the overlays
         addOverlayPackage(OVERLAY, TARGET, USER, false, true, 1);
         addOverlayPackage(OVERLAY2, TARGET, USER, false, true, 0);
         impl.updateOverlaysForUser(USER);
 
         final OverlayInfo o3 = impl.getOverlayInfo(OVERLAY, USER);
-        final OverlayInfo o4 = impl.getOverlayInfo(OVERLAY2, USER);
         assertNotNull(o3);
-        assertNotNull(o4);
         assertEquals(1, o3.priority);
+
+        final OverlayInfo o4 = impl.getOverlayInfo(OVERLAY2, USER);
+        assertNotNull(o4);
         assertEquals(0, o4.priority);
+        assertTrue(o1.isEnabled());
     }
 }