Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6cd7eba8 authored by Alina Zaidi's avatar Alina Zaidi
Browse files

[Dev options] Remove the use of java.lang.System.setProperty

java.lang.System properties are not shared amongst processes and does
not work as intented system level caching mechanism

Test: Updated tests
Bug: 348193756
Flag: com.android.window.flags.show_desktop_windowing_dev_option
Change-Id: I4969b1c67bc37a1ba45e0c30e43defd323079229
parent 78297ef2
Loading
Loading
Loading
Loading
+9 −42
Original line number Diff line number Diff line
@@ -39,8 +39,6 @@ enum class DesktopModeFlags(

  /**
   * Determines state of flag based on the actual flag and desktop mode developer option overrides.
   *
   * Note, this method makes sure that a constant developer toggle overrides is read until reboot.
   */
  fun isEnabled(context: Context): Boolean =
      if (!Flags.showDesktopWindowingDevOption() ||
@@ -65,7 +63,7 @@ enum class DesktopModeFlags(
            ?: run {
              val override = getToggleOverrideFromSystem(context)
              // Cache toggle override the first time we encounter context. Override does not change
              // with context, as context is just used to fetch System Property and Settings.Global
              // with context, as context is just used to fetch Settings.Global
              cachedToggleOverride = override
              Log.d(TAG, "Toggle override initialized to: $override")
              override
@@ -74,29 +72,13 @@ enum class DesktopModeFlags(
    return override
  }

  private fun getToggleOverrideFromSystem(context: Context): ToggleOverride {
    // A non-persistent System Property is used to store override to ensure it remains
    // constant till reboot.
    val overrideFromSystemProperties: ToggleOverride? =
        System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, null).convertToToggleOverride()
    return overrideFromSystemProperties
        ?: run {
          // Read Setting Global if System Property is not present (just after reboot)
          // or not valid (user manually changed the value)
          val overrideFromSettingsGlobal =
  private fun getToggleOverrideFromSystem(context: Context): ToggleOverride =
      convertToToggleOverrideWithFallback(
          Settings.Global.getInt(
              context.contentResolver,
              Settings.Global.DEVELOPMENT_OVERRIDE_DESKTOP_MODE_FEATURES,
              ToggleOverride.OVERRIDE_UNSET.setting),
          ToggleOverride.OVERRIDE_UNSET)
          // Initialize System Property
          System.setProperty(
              SYSTEM_PROPERTY_OVERRIDE_KEY, overrideFromSettingsGlobal.setting.toString())

          overrideFromSettingsGlobal
        }
  }

  /**
   * Override state of desktop mode developer option toggle.
@@ -113,27 +95,12 @@ enum class DesktopModeFlags(
    OVERRIDE_ON(1)
  }

  private fun String?.convertToToggleOverride(): ToggleOverride? {
    val intValue = this?.toIntOrNull() ?: return null
    return settingToToggleOverrideMap[intValue]
        ?: run {
          Log.w(TAG, "Unknown toggleOverride int $intValue")
          null
        }
  }

  companion object {
    private const val TAG = "DesktopModeFlags"

    /**
     * Key for non-persistent System Property which is used to store desktop windowing developer
     * option overrides.
     */
    private const val SYSTEM_PROPERTY_OVERRIDE_KEY = "sys.wmshell.desktopmode.dev_toggle_override"

    /**
     * Local cache for toggle override, which is initialized once on its first access. It needs to
     * be refreshed only on reboots as overridden state takes effect on reboots.
     * be refreshed only on reboots as overridden state is expected to take effect on reboots.
     */
    private var cachedToggleOverride: ToggleOverride? = null

+0 −109
Original line number Diff line number Diff line
@@ -183,108 +183,6 @@ class DesktopModeFlagsTest : ShellTestCase() {
    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue()
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
  @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  fun isEnabled_noSystemProperty_overrideOn_featureFlagOff_returnsTrueAndStoresPropertyOn() {
    System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY)
    setOverride(OVERRIDE_ON.setting)

    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue()
    // Store System Property if not present
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_ON.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  fun isEnabled_noSystemProperty_overrideUnset_featureFlagOn_returnsTrueAndStoresPropertyUnset() {
    System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY)
    setOverride(OVERRIDE_UNSET.setting)

    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue()
    // Store System Property if not present
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_UNSET.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
  @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  fun isEnabled_noSystemProperty_overrideUnset_featureFlagOff_returnsFalseAndStoresPropertyUnset() {
    System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY)
    setOverride(OVERRIDE_UNSET.setting)

    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse()
    // Store System Property if not present
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_UNSET.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  @Suppress("ktlint:standard:max-line-length")
  fun isEnabled_systemPropertyNotInteger_overrideOff_featureFlagOn_returnsFalseAndStoresPropertyOff() {
    System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, "abc")
    setOverride(OVERRIDE_OFF.setting)

    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse()
    // Store System Property if currently invalid
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_OFF.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  @Suppress("ktlint:standard:max-line-length")
  fun isEnabled_systemPropertyInvalidInteger_overrideOff_featureFlagOn_returnsFalseAndStoresPropertyOff() {
    System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, "-2")
    setOverride(OVERRIDE_OFF.setting)

    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse()
    // Store System Property if currently invalid
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_OFF.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  fun isEnabled_systemPropertyOff_overrideOn_featureFlagOn_returnsFalseAndDoesNotUpdateProperty() {
    System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, OVERRIDE_OFF.setting.toString())
    setOverride(OVERRIDE_ON.setting)

    // Have a consistent override until reboot
    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse()
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_OFF.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
  @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  fun isEnabled_systemPropertyOn_overrideOff_featureFlagOff_returnsTrueAndDoesNotUpdateProperty() {
    System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, OVERRIDE_ON.setting.toString())
    setOverride(OVERRIDE_OFF.setting)

    // Have a consistent override until reboot
    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue()
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_ON.setting.toString())
  }

  @Test
  @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
  @Suppress("ktlint:standard:max-line-length")
  fun isEnabled_systemPropertyUnset_overrideOff_featureFlagOn_returnsTrueAndDoesNotUpdateProperty() {
    System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, OVERRIDE_UNSET.setting.toString())
    setOverride(OVERRIDE_OFF.setting)

    // Have a consistent override until reboot
    assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue()
    assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
        .isEqualTo(OVERRIDE_UNSET.setting.toString())
  }

  @Test
  @EnableFlags(
      FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION,
@@ -445,12 +343,5 @@ class DesktopModeFlagsTest : ShellTestCase() {
      DesktopModeFlags::class.java.getDeclaredField("cachedToggleOverride")
    cachedToggleOverride.isAccessible = true
    cachedToggleOverride.set(null, null)

    // Clear override cache stored in System property
    System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY)
  }

  private companion object {
    const val SYSTEM_PROPERTY_OVERRIDE_KEY = "sys.wmshell.desktopmode.dev_toggle_override"
  }
}
+3 −43
Original line number Diff line number Diff line
@@ -47,16 +47,13 @@ public enum DesktopModeFlagsUtil {
            Flags::enableDesktopWindowingWallpaperActivity, /* shouldOverrideByDevOption= */ true);

    private static final String TAG = "DesktopModeFlagsUtil";
    private static final String SYSTEM_PROPERTY_OVERRIDE_KEY =
            "sys.wmshell.desktopmode.dev_toggle_override";

    // Function called to obtain aconfig flag value.
    private final Supplier<Boolean> mFlagFunction;
    // Whether the flag state should be affected by developer option.
    private final boolean mShouldOverrideByDevOption;

    // Local cache for toggle override, which is initialized once on its first access. It needs to
    // be refreshed only on reboots as overridden state takes effect on reboots.
    // be refreshed only on reboots as overridden state is expected to take effect on reboots.
    private static ToggleOverride sCachedToggleOverride;

    DesktopModeFlagsUtil(Supplier<Boolean> flagFunction, boolean shouldOverrideByDevOption) {
@@ -67,9 +64,6 @@ public enum DesktopModeFlagsUtil {
    /**
     * Determines state of flag based on the actual flag and desktop mode developer option
     * overrides.
     *
     * Note: this method makes sure that a constant developer toggle overrides is read until
     * reboot.
     */
    public boolean isEnabled(Context context) {
        if (!Flags.showDesktopWindowingDevOption()
@@ -102,49 +96,15 @@ public enum DesktopModeFlagsUtil {
    }

    /**
     *  Returns {@link ToggleOverride} from a non-persistent system property if present. Otherwise
     *  initializes the system property by reading Settings.Global.
     *  Returns {@link ToggleOverride} from Settings.Global set by toggle.
     */
    private ToggleOverride getToggleOverrideFromSystem(Context context) {
        // A non-persistent System Property is used to store override to ensure it remains
        // constant till reboot.
        String overrideProperty = System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, null);
        ToggleOverride overrideFromSystemProperties = convertToToggleOverride(overrideProperty);

        // If valid system property, return it
        if (overrideFromSystemProperties != null) {
            return overrideFromSystemProperties;
        }

        // Fallback when System Property is not present (just after reboot) or not valid (user
        // manually changed the value): Read from Settings.Global
        int settingValue = Settings.Global.getInt(
                context.getContentResolver(),
                Settings.Global.DEVELOPMENT_OVERRIDE_DESKTOP_MODE_FEATURES,
                OVERRIDE_UNSET.getSetting()
        );
        ToggleOverride overrideFromSettingsGlobal =
                ToggleOverride.fromSetting(settingValue, OVERRIDE_UNSET);
        // Initialize System Property
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, String.valueOf(settingValue));
        return overrideFromSettingsGlobal;
    }

    /**
     * Converts {@code intString} into {@link ToggleOverride}. Return {@code null} if
     * {@code intString} does not correspond to a {@link ToggleOverride}.
     */
    private static @Nullable ToggleOverride convertToToggleOverride(
            @Nullable String intString
    ) {
        if (intString == null) return null;
        try {
            int intValue = Integer.parseInt(intString);
            return ToggleOverride.fromSetting(intValue, null);
        } catch (NumberFormatException e) {
            Log.w(TAG, "Unknown toggleOverride int " + intString);
            return null;
        }
        return ToggleOverride.fromSetting(settingValue, OVERRIDE_UNSET);
    }

    /** Override state of desktop mode developer option toggle. */
+0 −110
Original line number Diff line number Diff line
@@ -63,9 +63,6 @@ public class DesktopModeFlagsUtilTest extends WindowTestsBase {
        resetCache();
    }

    private static final String SYSTEM_PROPERTY_OVERRIDE_KEY =
            "sys.wmshell.desktopmode.dev_toggle_override";

    @Test
    @DisableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
    @EnableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
@@ -189,110 +186,6 @@ public class DesktopModeFlagsUtilTest extends WindowTestsBase {
        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue();
    }

    @Test
    @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
    @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
    public void isEnabled_noProperty_overrideOn_featureFlagOff_returnsTrueAndPropertyOn() {
        System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY);
        setOverride(OVERRIDE_ON.getSetting());

        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue();
        // Store System Property if not present
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(OVERRIDE_ON.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE})
    public void isEnabled_noProperty_overrideUnset_featureFlagOn_returnsTrueAndPropertyUnset() {
        System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY);
        setOverride(DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting());

        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue();
        // Store System Property if not present
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(
                        DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting()));
    }

    @Test
    @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
    @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
    public void isEnabled_noProperty_overrideUnset_featureFlagOff_returnsFalseAndPropertyUnset() {
        System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY);
        setOverride(DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting());

        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse();
        // Store System Property if not present
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(
                        DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE})
    public void isEnabled_propertyNotInt_overrideOff_featureFlagOn_returnsFalseAndPropertyOff() {
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, "abc");
        setOverride(OVERRIDE_OFF.getSetting());

        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse();
        // Store System Property if currently invalid
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(OVERRIDE_OFF.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE})
    public void isEnabled_propertyInvalid_overrideOff_featureFlagOn_returnsFalseAndPropertyOff() {
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, "-2");
        setOverride(OVERRIDE_OFF.getSetting());

        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse();
        // Store System Property if currently invalid
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(OVERRIDE_OFF.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE})
    public void isEnabled_propertyOff_overrideOn_featureFlagOn_returnsFalseAndnoPropertyUpdate() {
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, String.valueOf(
                OVERRIDE_OFF.getSetting()));
        setOverride(OVERRIDE_ON.getSetting());

        // Have a consistent override until reboot
        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isFalse();
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(OVERRIDE_OFF.getSetting()));
    }

    @Test
    @EnableFlags(FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION)
    @DisableFlags(FLAG_ENABLE_DESKTOP_WINDOWING_MODE)
    public void isEnabled_propertyOn_overrideOff_featureFlagOff_returnsTrueAndnoPropertyUpdate() {
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY, String.valueOf(OVERRIDE_ON.getSetting()));
        setOverride(OVERRIDE_OFF.getSetting());

        // Have a consistent override until reboot
        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue();
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(OVERRIDE_ON.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE})
    public void isEnabled_propertyUnset_overrideOff_featureFlagOn_returnsTrueAndnoPropertyUpdate() {
        System.setProperty(SYSTEM_PROPERTY_OVERRIDE_KEY,
                String.valueOf(DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting()));
        setOverride(OVERRIDE_OFF.getSetting());

        // Have a consistent override until reboot
        assertThat(DESKTOP_WINDOWING_MODE.isEnabled(mContext)).isTrue();
        assertThat(System.getProperty(SYSTEM_PROPERTY_OVERRIDE_KEY))
                .isEqualTo(String.valueOf(
                        DesktopModeFlagsUtil.ToggleOverride.OVERRIDE_UNSET.getSetting()));
    }

    @Test
    @EnableFlags({FLAG_SHOW_DESKTOP_WINDOWING_DEV_OPTION, FLAG_ENABLE_DESKTOP_WINDOWING_MODE,
            FLAG_ENABLE_DESKTOP_WINDOWING_WALLPAPER_ACTIVITY})
@@ -452,8 +345,5 @@ public class DesktopModeFlagsUtilTest extends WindowTestsBase {
                "sCachedToggleOverride");
        cachedToggleOverride.setAccessible(true);
        cachedToggleOverride.set(null, null);

        // Clear override cache stored in System property
        System.clearProperty(SYSTEM_PROPERTY_OVERRIDE_KEY);
    }
}